// Copyright 2016-2022 The Libsacloud Authors
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//      http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

// generated by 'github.com/sacloud/libsacloud/internal/tools/gen-api-tracer'; DO NOT EDIT

package trace

import (
	"context"
	"encoding/json"
	"log"
	"sync"

	"github.com/sacloud/libsacloud/v2/sacloud"
	"github.com/sacloud/libsacloud/v2/sacloud/types"
)

var initOnce sync.Once

// AddClientFactoryHooks add client factory hooks
func AddClientFactoryHooks() {
	initOnce.Do(func() {
		addClientFactoryHooks()
	})
}

func addClientFactoryHooks() {
	sacloud.AddClientFacotyHookFunc("Archive", func(in interface{}) interface{} {
		return NewArchiveTracer(in.(sacloud.ArchiveAPI))
	})
	sacloud.AddClientFacotyHookFunc("AuthStatus", func(in interface{}) interface{} {
		return NewAuthStatusTracer(in.(sacloud.AuthStatusAPI))
	})
	sacloud.AddClientFacotyHookFunc("AutoBackup", func(in interface{}) interface{} {
		return NewAutoBackupTracer(in.(sacloud.AutoBackupAPI))
	})
	sacloud.AddClientFacotyHookFunc("Bill", func(in interface{}) interface{} {
		return NewBillTracer(in.(sacloud.BillAPI))
	})
	sacloud.AddClientFacotyHookFunc("Bridge", func(in interface{}) interface{} {
		return NewBridgeTracer(in.(sacloud.BridgeAPI))
	})
	sacloud.AddClientFacotyHookFunc("CDROM", func(in interface{}) interface{} {
		return NewCDROMTracer(in.(sacloud.CDROMAPI))
	})
	sacloud.AddClientFacotyHookFunc("CertificateAuthority", func(in interface{}) interface{} {
		return NewCertificateAuthorityTracer(in.(sacloud.CertificateAuthorityAPI))
	})
	sacloud.AddClientFacotyHookFunc("ContainerRegistry", func(in interface{}) interface{} {
		return NewContainerRegistryTracer(in.(sacloud.ContainerRegistryAPI))
	})
	sacloud.AddClientFacotyHookFunc("Coupon", func(in interface{}) interface{} {
		return NewCouponTracer(in.(sacloud.CouponAPI))
	})
	sacloud.AddClientFacotyHookFunc("Database", func(in interface{}) interface{} {
		return NewDatabaseTracer(in.(sacloud.DatabaseAPI))
	})
	sacloud.AddClientFacotyHookFunc("Disk", func(in interface{}) interface{} {
		return NewDiskTracer(in.(sacloud.DiskAPI))
	})
	sacloud.AddClientFacotyHookFunc("DiskPlan", func(in interface{}) interface{} {
		return NewDiskPlanTracer(in.(sacloud.DiskPlanAPI))
	})
	sacloud.AddClientFacotyHookFunc("DNS", func(in interface{}) interface{} {
		return NewDNSTracer(in.(sacloud.DNSAPI))
	})
	sacloud.AddClientFacotyHookFunc("EnhancedDB", func(in interface{}) interface{} {
		return NewEnhancedDBTracer(in.(sacloud.EnhancedDBAPI))
	})
	sacloud.AddClientFacotyHookFunc("ESME", func(in interface{}) interface{} {
		return NewESMETracer(in.(sacloud.ESMEAPI))
	})
	sacloud.AddClientFacotyHookFunc("GSLB", func(in interface{}) interface{} {
		return NewGSLBTracer(in.(sacloud.GSLBAPI))
	})
	sacloud.AddClientFacotyHookFunc("Icon", func(in interface{}) interface{} {
		return NewIconTracer(in.(sacloud.IconAPI))
	})
	sacloud.AddClientFacotyHookFunc("Interface", func(in interface{}) interface{} {
		return NewInterfaceTracer(in.(sacloud.InterfaceAPI))
	})
	sacloud.AddClientFacotyHookFunc("Internet", func(in interface{}) interface{} {
		return NewInternetTracer(in.(sacloud.InternetAPI))
	})
	sacloud.AddClientFacotyHookFunc("InternetPlan", func(in interface{}) interface{} {
		return NewInternetPlanTracer(in.(sacloud.InternetPlanAPI))
	})
	sacloud.AddClientFacotyHookFunc("IPAddress", func(in interface{}) interface{} {
		return NewIPAddressTracer(in.(sacloud.IPAddressAPI))
	})
	sacloud.AddClientFacotyHookFunc("IPv6Net", func(in interface{}) interface{} {
		return NewIPv6NetTracer(in.(sacloud.IPv6NetAPI))
	})
	sacloud.AddClientFacotyHookFunc("IPv6Addr", func(in interface{}) interface{} {
		return NewIPv6AddrTracer(in.(sacloud.IPv6AddrAPI))
	})
	sacloud.AddClientFacotyHookFunc("License", func(in interface{}) interface{} {
		return NewLicenseTracer(in.(sacloud.LicenseAPI))
	})
	sacloud.AddClientFacotyHookFunc("LicenseInfo", func(in interface{}) interface{} {
		return NewLicenseInfoTracer(in.(sacloud.LicenseInfoAPI))
	})
	sacloud.AddClientFacotyHookFunc("LoadBalancer", func(in interface{}) interface{} {
		return NewLoadBalancerTracer(in.(sacloud.LoadBalancerAPI))
	})
	sacloud.AddClientFacotyHookFunc("LocalRouter", func(in interface{}) interface{} {
		return NewLocalRouterTracer(in.(sacloud.LocalRouterAPI))
	})
	sacloud.AddClientFacotyHookFunc("MobileGateway", func(in interface{}) interface{} {
		return NewMobileGatewayTracer(in.(sacloud.MobileGatewayAPI))
	})
	sacloud.AddClientFacotyHookFunc("NFS", func(in interface{}) interface{} {
		return NewNFSTracer(in.(sacloud.NFSAPI))
	})
	sacloud.AddClientFacotyHookFunc("Note", func(in interface{}) interface{} {
		return NewNoteTracer(in.(sacloud.NoteAPI))
	})
	sacloud.AddClientFacotyHookFunc("PacketFilter", func(in interface{}) interface{} {
		return NewPacketFilterTracer(in.(sacloud.PacketFilterAPI))
	})
	sacloud.AddClientFacotyHookFunc("PrivateHost", func(in interface{}) interface{} {
		return NewPrivateHostTracer(in.(sacloud.PrivateHostAPI))
	})
	sacloud.AddClientFacotyHookFunc("PrivateHostPlan", func(in interface{}) interface{} {
		return NewPrivateHostPlanTracer(in.(sacloud.PrivateHostPlanAPI))
	})
	sacloud.AddClientFacotyHookFunc("ProxyLB", func(in interface{}) interface{} {
		return NewProxyLBTracer(in.(sacloud.ProxyLBAPI))
	})
	sacloud.AddClientFacotyHookFunc("Region", func(in interface{}) interface{} {
		return NewRegionTracer(in.(sacloud.RegionAPI))
	})
	sacloud.AddClientFacotyHookFunc("Server", func(in interface{}) interface{} {
		return NewServerTracer(in.(sacloud.ServerAPI))
	})
	sacloud.AddClientFacotyHookFunc("ServerPlan", func(in interface{}) interface{} {
		return NewServerPlanTracer(in.(sacloud.ServerPlanAPI))
	})
	sacloud.AddClientFacotyHookFunc("ServiceClass", func(in interface{}) interface{} {
		return NewServiceClassTracer(in.(sacloud.ServiceClassAPI))
	})
	sacloud.AddClientFacotyHookFunc("SIM", func(in interface{}) interface{} {
		return NewSIMTracer(in.(sacloud.SIMAPI))
	})
	sacloud.AddClientFacotyHookFunc("SimpleMonitor", func(in interface{}) interface{} {
		return NewSimpleMonitorTracer(in.(sacloud.SimpleMonitorAPI))
	})
	sacloud.AddClientFacotyHookFunc("SSHKey", func(in interface{}) interface{} {
		return NewSSHKeyTracer(in.(sacloud.SSHKeyAPI))
	})
	sacloud.AddClientFacotyHookFunc("Subnet", func(in interface{}) interface{} {
		return NewSubnetTracer(in.(sacloud.SubnetAPI))
	})
	sacloud.AddClientFacotyHookFunc("Switch", func(in interface{}) interface{} {
		return NewSwitchTracer(in.(sacloud.SwitchAPI))
	})
	sacloud.AddClientFacotyHookFunc("VPCRouter", func(in interface{}) interface{} {
		return NewVPCRouterTracer(in.(sacloud.VPCRouterAPI))
	})
	sacloud.AddClientFacotyHookFunc("WebAccel", func(in interface{}) interface{} {
		return NewWebAccelTracer(in.(sacloud.WebAccelAPI))
	})
	sacloud.AddClientFacotyHookFunc("Zone", func(in interface{}) interface{} {
		return NewZoneTracer(in.(sacloud.ZoneAPI))
	})
}

/*************************************************
* ArchiveTracer
*************************************************/

// ArchiveTracer is for trace ArchiveOp operations
type ArchiveTracer struct {
	Internal sacloud.ArchiveAPI
}

// NewArchiveTracer creates new ArchiveTracer instance
func NewArchiveTracer(in sacloud.ArchiveAPI) sacloud.ArchiveAPI {
	return &ArchiveTracer{
		Internal: in,
	}
}

// Find is API call with trace log
func (t *ArchiveTracer) Find(ctx context.Context, zone string, conditions *sacloud.FindCondition) (*sacloud.ArchiveFindResult, error) {
	log.Println("[TRACE] ArchiveAPI.Find start")
	targetArguments := struct {
		Argzone       string
		Argconditions *sacloud.FindCondition `json:"conditions"`
	}{
		Argzone:       zone,
		Argconditions: conditions,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] ArchiveAPI.Find end")
	}()

	result, err := t.Internal.Find(ctx, zone, conditions)
	targetResults := struct {
		Result *sacloud.ArchiveFindResult
		Error  error
	}{
		Result: result,
		Error:  err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return result, err
}

// Create is API call with trace log
func (t *ArchiveTracer) Create(ctx context.Context, zone string, param *sacloud.ArchiveCreateRequest) (*sacloud.Archive, error) {
	log.Println("[TRACE] ArchiveAPI.Create start")
	targetArguments := struct {
		Argzone  string
		Argparam *sacloud.ArchiveCreateRequest `json:"param"`
	}{
		Argzone:  zone,
		Argparam: param,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] ArchiveAPI.Create end")
	}()

	resultArchive, err := t.Internal.Create(ctx, zone, param)
	targetResults := struct {
		Archive *sacloud.Archive
		Error   error
	}{
		Archive: resultArchive,
		Error:   err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultArchive, err
}

// CreateBlank is API call with trace log
func (t *ArchiveTracer) CreateBlank(ctx context.Context, zone string, param *sacloud.ArchiveCreateBlankRequest) (*sacloud.Archive, *sacloud.FTPServer, error) {
	log.Println("[TRACE] ArchiveAPI.CreateBlank start")
	targetArguments := struct {
		Argzone  string
		Argparam *sacloud.ArchiveCreateBlankRequest `json:"param"`
	}{
		Argzone:  zone,
		Argparam: param,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] ArchiveAPI.CreateBlank end")
	}()

	resultArchive, resultFTPServer, err := t.Internal.CreateBlank(ctx, zone, param)
	targetResults := struct {
		Archive   *sacloud.Archive
		FTPServer *sacloud.FTPServer
		Error     error
	}{
		Archive:   resultArchive,
		FTPServer: resultFTPServer,
		Error:     err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultArchive, resultFTPServer, err
}

// Read is API call with trace log
func (t *ArchiveTracer) Read(ctx context.Context, zone string, id types.ID) (*sacloud.Archive, error) {
	log.Println("[TRACE] ArchiveAPI.Read start")
	targetArguments := struct {
		Argzone string
		Argid   types.ID `json:"id"`
	}{
		Argzone: zone,
		Argid:   id,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] ArchiveAPI.Read end")
	}()

	resultArchive, err := t.Internal.Read(ctx, zone, id)
	targetResults := struct {
		Archive *sacloud.Archive
		Error   error
	}{
		Archive: resultArchive,
		Error:   err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultArchive, err
}

// Update is API call with trace log
func (t *ArchiveTracer) Update(ctx context.Context, zone string, id types.ID, param *sacloud.ArchiveUpdateRequest) (*sacloud.Archive, error) {
	log.Println("[TRACE] ArchiveAPI.Update start")
	targetArguments := struct {
		Argzone  string
		Argid    types.ID                      `json:"id"`
		Argparam *sacloud.ArchiveUpdateRequest `json:"param"`
	}{
		Argzone:  zone,
		Argid:    id,
		Argparam: param,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] ArchiveAPI.Update end")
	}()

	resultArchive, err := t.Internal.Update(ctx, zone, id, param)
	targetResults := struct {
		Archive *sacloud.Archive
		Error   error
	}{
		Archive: resultArchive,
		Error:   err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultArchive, err
}

// Delete is API call with trace log
func (t *ArchiveTracer) Delete(ctx context.Context, zone string, id types.ID) error {
	log.Println("[TRACE] ArchiveAPI.Delete start")
	targetArguments := struct {
		Argzone string
		Argid   types.ID `json:"id"`
	}{
		Argzone: zone,
		Argid:   id,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] ArchiveAPI.Delete end")
	}()

	err := t.Internal.Delete(ctx, zone, id)
	targetResults := struct {
		Error error
	}{
		Error: err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return err
}

// OpenFTP is API call with trace log
func (t *ArchiveTracer) OpenFTP(ctx context.Context, zone string, id types.ID, openOption *sacloud.OpenFTPRequest) (*sacloud.FTPServer, error) {
	log.Println("[TRACE] ArchiveAPI.OpenFTP start")
	targetArguments := struct {
		Argzone       string
		Argid         types.ID                `json:"id"`
		ArgopenOption *sacloud.OpenFTPRequest `json:"openOption"`
	}{
		Argzone:       zone,
		Argid:         id,
		ArgopenOption: openOption,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] ArchiveAPI.OpenFTP end")
	}()

	resultFTPServer, err := t.Internal.OpenFTP(ctx, zone, id, openOption)
	targetResults := struct {
		FTPServer *sacloud.FTPServer
		Error     error
	}{
		FTPServer: resultFTPServer,
		Error:     err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultFTPServer, err
}

// CloseFTP is API call with trace log
func (t *ArchiveTracer) CloseFTP(ctx context.Context, zone string, id types.ID) error {
	log.Println("[TRACE] ArchiveAPI.CloseFTP start")
	targetArguments := struct {
		Argzone string
		Argid   types.ID `json:"id"`
	}{
		Argzone: zone,
		Argid:   id,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] ArchiveAPI.CloseFTP end")
	}()

	err := t.Internal.CloseFTP(ctx, zone, id)
	targetResults := struct {
		Error error
	}{
		Error: err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return err
}

// Share is API call with trace log
func (t *ArchiveTracer) Share(ctx context.Context, zone string, id types.ID) (*sacloud.ArchiveShareInfo, error) {
	log.Println("[TRACE] ArchiveAPI.Share start")
	targetArguments := struct {
		Argzone string
		Argid   types.ID `json:"id"`
	}{
		Argzone: zone,
		Argid:   id,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] ArchiveAPI.Share end")
	}()

	resultArchiveShareInfo, err := t.Internal.Share(ctx, zone, id)
	targetResults := struct {
		ArchiveShareInfo *sacloud.ArchiveShareInfo
		Error            error
	}{
		ArchiveShareInfo: resultArchiveShareInfo,
		Error:            err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultArchiveShareInfo, err
}

// CreateFromShared is API call with trace log
func (t *ArchiveTracer) CreateFromShared(ctx context.Context, zone string, sourceArchiveID types.ID, destZoneID types.ID, param *sacloud.ArchiveCreateRequestFromShared) (*sacloud.Archive, error) {
	log.Println("[TRACE] ArchiveAPI.CreateFromShared start")
	targetArguments := struct {
		Argzone            string
		ArgsourceArchiveID types.ID                                `json:"sourceArchiveID"`
		ArgdestZoneID      types.ID                                `json:"destZoneID"`
		Argparam           *sacloud.ArchiveCreateRequestFromShared `json:"param"`
	}{
		Argzone:            zone,
		ArgsourceArchiveID: sourceArchiveID,
		ArgdestZoneID:      destZoneID,
		Argparam:           param,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] ArchiveAPI.CreateFromShared end")
	}()

	resultArchive, err := t.Internal.CreateFromShared(ctx, zone, sourceArchiveID, destZoneID, param)
	targetResults := struct {
		Archive *sacloud.Archive
		Error   error
	}{
		Archive: resultArchive,
		Error:   err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultArchive, err
}

// Transfer is API call with trace log
func (t *ArchiveTracer) Transfer(ctx context.Context, zone string, sourceArchiveID types.ID, destZoneID types.ID, param *sacloud.ArchiveTransferRequest) (*sacloud.Archive, error) {
	log.Println("[TRACE] ArchiveAPI.Transfer start")
	targetArguments := struct {
		Argzone            string
		ArgsourceArchiveID types.ID                        `json:"sourceArchiveID"`
		ArgdestZoneID      types.ID                        `json:"destZoneID"`
		Argparam           *sacloud.ArchiveTransferRequest `json:"param"`
	}{
		Argzone:            zone,
		ArgsourceArchiveID: sourceArchiveID,
		ArgdestZoneID:      destZoneID,
		Argparam:           param,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] ArchiveAPI.Transfer end")
	}()

	resultArchive, err := t.Internal.Transfer(ctx, zone, sourceArchiveID, destZoneID, param)
	targetResults := struct {
		Archive *sacloud.Archive
		Error   error
	}{
		Archive: resultArchive,
		Error:   err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultArchive, err
}

/*************************************************
* AuthStatusTracer
*************************************************/

// AuthStatusTracer is for trace AuthStatusOp operations
type AuthStatusTracer struct {
	Internal sacloud.AuthStatusAPI
}

// NewAuthStatusTracer creates new AuthStatusTracer instance
func NewAuthStatusTracer(in sacloud.AuthStatusAPI) sacloud.AuthStatusAPI {
	return &AuthStatusTracer{
		Internal: in,
	}
}

// Read is API call with trace log
func (t *AuthStatusTracer) Read(ctx context.Context) (*sacloud.AuthStatus, error) {
	log.Println("[TRACE] AuthStatusAPI.Read start")
	targetArguments := struct {
	}{}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] AuthStatusAPI.Read end")
	}()

	resultAuthStatus, err := t.Internal.Read(ctx)
	targetResults := struct {
		AuthStatus *sacloud.AuthStatus
		Error      error
	}{
		AuthStatus: resultAuthStatus,
		Error:      err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultAuthStatus, err
}

/*************************************************
* AutoBackupTracer
*************************************************/

// AutoBackupTracer is for trace AutoBackupOp operations
type AutoBackupTracer struct {
	Internal sacloud.AutoBackupAPI
}

// NewAutoBackupTracer creates new AutoBackupTracer instance
func NewAutoBackupTracer(in sacloud.AutoBackupAPI) sacloud.AutoBackupAPI {
	return &AutoBackupTracer{
		Internal: in,
	}
}

// Find is API call with trace log
func (t *AutoBackupTracer) Find(ctx context.Context, zone string, conditions *sacloud.FindCondition) (*sacloud.AutoBackupFindResult, error) {
	log.Println("[TRACE] AutoBackupAPI.Find start")
	targetArguments := struct {
		Argzone       string
		Argconditions *sacloud.FindCondition `json:"conditions"`
	}{
		Argzone:       zone,
		Argconditions: conditions,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] AutoBackupAPI.Find end")
	}()

	result, err := t.Internal.Find(ctx, zone, conditions)
	targetResults := struct {
		Result *sacloud.AutoBackupFindResult
		Error  error
	}{
		Result: result,
		Error:  err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return result, err
}

// Create is API call with trace log
func (t *AutoBackupTracer) Create(ctx context.Context, zone string, param *sacloud.AutoBackupCreateRequest) (*sacloud.AutoBackup, error) {
	log.Println("[TRACE] AutoBackupAPI.Create start")
	targetArguments := struct {
		Argzone  string
		Argparam *sacloud.AutoBackupCreateRequest `json:"param"`
	}{
		Argzone:  zone,
		Argparam: param,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] AutoBackupAPI.Create end")
	}()

	resultAutoBackup, err := t.Internal.Create(ctx, zone, param)
	targetResults := struct {
		AutoBackup *sacloud.AutoBackup
		Error      error
	}{
		AutoBackup: resultAutoBackup,
		Error:      err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultAutoBackup, err
}

// Read is API call with trace log
func (t *AutoBackupTracer) Read(ctx context.Context, zone string, id types.ID) (*sacloud.AutoBackup, error) {
	log.Println("[TRACE] AutoBackupAPI.Read start")
	targetArguments := struct {
		Argzone string
		Argid   types.ID `json:"id"`
	}{
		Argzone: zone,
		Argid:   id,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] AutoBackupAPI.Read end")
	}()

	resultAutoBackup, err := t.Internal.Read(ctx, zone, id)
	targetResults := struct {
		AutoBackup *sacloud.AutoBackup
		Error      error
	}{
		AutoBackup: resultAutoBackup,
		Error:      err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultAutoBackup, err
}

// Update is API call with trace log
func (t *AutoBackupTracer) Update(ctx context.Context, zone string, id types.ID, param *sacloud.AutoBackupUpdateRequest) (*sacloud.AutoBackup, error) {
	log.Println("[TRACE] AutoBackupAPI.Update start")
	targetArguments := struct {
		Argzone  string
		Argid    types.ID                         `json:"id"`
		Argparam *sacloud.AutoBackupUpdateRequest `json:"param"`
	}{
		Argzone:  zone,
		Argid:    id,
		Argparam: param,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] AutoBackupAPI.Update end")
	}()

	resultAutoBackup, err := t.Internal.Update(ctx, zone, id, param)
	targetResults := struct {
		AutoBackup *sacloud.AutoBackup
		Error      error
	}{
		AutoBackup: resultAutoBackup,
		Error:      err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultAutoBackup, err
}

// UpdateSettings is API call with trace log
func (t *AutoBackupTracer) UpdateSettings(ctx context.Context, zone string, id types.ID, param *sacloud.AutoBackupUpdateSettingsRequest) (*sacloud.AutoBackup, error) {
	log.Println("[TRACE] AutoBackupAPI.UpdateSettings start")
	targetArguments := struct {
		Argzone  string
		Argid    types.ID                                 `json:"id"`
		Argparam *sacloud.AutoBackupUpdateSettingsRequest `json:"param"`
	}{
		Argzone:  zone,
		Argid:    id,
		Argparam: param,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] AutoBackupAPI.UpdateSettings end")
	}()

	resultAutoBackup, err := t.Internal.UpdateSettings(ctx, zone, id, param)
	targetResults := struct {
		AutoBackup *sacloud.AutoBackup
		Error      error
	}{
		AutoBackup: resultAutoBackup,
		Error:      err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultAutoBackup, err
}

// Delete is API call with trace log
func (t *AutoBackupTracer) Delete(ctx context.Context, zone string, id types.ID) error {
	log.Println("[TRACE] AutoBackupAPI.Delete start")
	targetArguments := struct {
		Argzone string
		Argid   types.ID `json:"id"`
	}{
		Argzone: zone,
		Argid:   id,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] AutoBackupAPI.Delete end")
	}()

	err := t.Internal.Delete(ctx, zone, id)
	targetResults := struct {
		Error error
	}{
		Error: err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return err
}

/*************************************************
* BillTracer
*************************************************/

// BillTracer is for trace BillOp operations
type BillTracer struct {
	Internal sacloud.BillAPI
}

// NewBillTracer creates new BillTracer instance
func NewBillTracer(in sacloud.BillAPI) sacloud.BillAPI {
	return &BillTracer{
		Internal: in,
	}
}

// ByContract is API call with trace log
func (t *BillTracer) ByContract(ctx context.Context, accountID types.ID) (*sacloud.BillByContractResult, error) {
	log.Println("[TRACE] BillAPI.ByContract start")
	targetArguments := struct {
		ArgaccountID types.ID `json:"accountID"`
	}{
		ArgaccountID: accountID,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] BillAPI.ByContract end")
	}()

	result, err := t.Internal.ByContract(ctx, accountID)
	targetResults := struct {
		Result *sacloud.BillByContractResult
		Error  error
	}{
		Result: result,
		Error:  err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return result, err
}

// ByContractYear is API call with trace log
func (t *BillTracer) ByContractYear(ctx context.Context, accountID types.ID, year int) (*sacloud.BillByContractYearResult, error) {
	log.Println("[TRACE] BillAPI.ByContractYear start")
	targetArguments := struct {
		ArgaccountID types.ID `json:"accountID"`
		Argyear      int      `json:"year"`
	}{
		ArgaccountID: accountID,
		Argyear:      year,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] BillAPI.ByContractYear end")
	}()

	result, err := t.Internal.ByContractYear(ctx, accountID, year)
	targetResults := struct {
		Result *sacloud.BillByContractYearResult
		Error  error
	}{
		Result: result,
		Error:  err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return result, err
}

// ByContractYearMonth is API call with trace log
func (t *BillTracer) ByContractYearMonth(ctx context.Context, accountID types.ID, year int, month int) (*sacloud.BillByContractYearMonthResult, error) {
	log.Println("[TRACE] BillAPI.ByContractYearMonth start")
	targetArguments := struct {
		ArgaccountID types.ID `json:"accountID"`
		Argyear      int      `json:"year"`
		Argmonth     int      `json:"month"`
	}{
		ArgaccountID: accountID,
		Argyear:      year,
		Argmonth:     month,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] BillAPI.ByContractYearMonth end")
	}()

	result, err := t.Internal.ByContractYearMonth(ctx, accountID, year, month)
	targetResults := struct {
		Result *sacloud.BillByContractYearMonthResult
		Error  error
	}{
		Result: result,
		Error:  err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return result, err
}

// Read is API call with trace log
func (t *BillTracer) Read(ctx context.Context, id types.ID) (*sacloud.BillReadResult, error) {
	log.Println("[TRACE] BillAPI.Read start")
	targetArguments := struct {
		Argid types.ID `json:"id"`
	}{
		Argid: id,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] BillAPI.Read end")
	}()

	result, err := t.Internal.Read(ctx, id)
	targetResults := struct {
		Result *sacloud.BillReadResult
		Error  error
	}{
		Result: result,
		Error:  err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return result, err
}

// Details is API call with trace log
func (t *BillTracer) Details(ctx context.Context, MemberCode string, id types.ID) (*sacloud.BillDetailsResult, error) {
	log.Println("[TRACE] BillAPI.Details start")
	targetArguments := struct {
		ArgMemberCode string   `json:"MemberCode"`
		Argid         types.ID `json:"id"`
	}{
		ArgMemberCode: MemberCode,
		Argid:         id,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] BillAPI.Details end")
	}()

	result, err := t.Internal.Details(ctx, MemberCode, id)
	targetResults := struct {
		Result *sacloud.BillDetailsResult
		Error  error
	}{
		Result: result,
		Error:  err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return result, err
}

// DetailsCSV is API call with trace log
func (t *BillTracer) DetailsCSV(ctx context.Context, MemberCode string, id types.ID) (*sacloud.BillDetailCSV, error) {
	log.Println("[TRACE] BillAPI.DetailsCSV start")
	targetArguments := struct {
		ArgMemberCode string   `json:"MemberCode"`
		Argid         types.ID `json:"id"`
	}{
		ArgMemberCode: MemberCode,
		Argid:         id,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] BillAPI.DetailsCSV end")
	}()

	resultBillDetailCSV, err := t.Internal.DetailsCSV(ctx, MemberCode, id)
	targetResults := struct {
		BillDetailCSV *sacloud.BillDetailCSV
		Error         error
	}{
		BillDetailCSV: resultBillDetailCSV,
		Error:         err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultBillDetailCSV, err
}

/*************************************************
* BridgeTracer
*************************************************/

// BridgeTracer is for trace BridgeOp operations
type BridgeTracer struct {
	Internal sacloud.BridgeAPI
}

// NewBridgeTracer creates new BridgeTracer instance
func NewBridgeTracer(in sacloud.BridgeAPI) sacloud.BridgeAPI {
	return &BridgeTracer{
		Internal: in,
	}
}

// Find is API call with trace log
func (t *BridgeTracer) Find(ctx context.Context, zone string, conditions *sacloud.FindCondition) (*sacloud.BridgeFindResult, error) {
	log.Println("[TRACE] BridgeAPI.Find start")
	targetArguments := struct {
		Argzone       string
		Argconditions *sacloud.FindCondition `json:"conditions"`
	}{
		Argzone:       zone,
		Argconditions: conditions,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] BridgeAPI.Find end")
	}()

	result, err := t.Internal.Find(ctx, zone, conditions)
	targetResults := struct {
		Result *sacloud.BridgeFindResult
		Error  error
	}{
		Result: result,
		Error:  err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return result, err
}

// Create is API call with trace log
func (t *BridgeTracer) Create(ctx context.Context, zone string, param *sacloud.BridgeCreateRequest) (*sacloud.Bridge, error) {
	log.Println("[TRACE] BridgeAPI.Create start")
	targetArguments := struct {
		Argzone  string
		Argparam *sacloud.BridgeCreateRequest `json:"param"`
	}{
		Argzone:  zone,
		Argparam: param,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] BridgeAPI.Create end")
	}()

	resultBridge, err := t.Internal.Create(ctx, zone, param)
	targetResults := struct {
		Bridge *sacloud.Bridge
		Error  error
	}{
		Bridge: resultBridge,
		Error:  err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultBridge, err
}

// Read is API call with trace log
func (t *BridgeTracer) Read(ctx context.Context, zone string, id types.ID) (*sacloud.Bridge, error) {
	log.Println("[TRACE] BridgeAPI.Read start")
	targetArguments := struct {
		Argzone string
		Argid   types.ID `json:"id"`
	}{
		Argzone: zone,
		Argid:   id,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] BridgeAPI.Read end")
	}()

	resultBridge, err := t.Internal.Read(ctx, zone, id)
	targetResults := struct {
		Bridge *sacloud.Bridge
		Error  error
	}{
		Bridge: resultBridge,
		Error:  err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultBridge, err
}

// Update is API call with trace log
func (t *BridgeTracer) Update(ctx context.Context, zone string, id types.ID, param *sacloud.BridgeUpdateRequest) (*sacloud.Bridge, error) {
	log.Println("[TRACE] BridgeAPI.Update start")
	targetArguments := struct {
		Argzone  string
		Argid    types.ID                     `json:"id"`
		Argparam *sacloud.BridgeUpdateRequest `json:"param"`
	}{
		Argzone:  zone,
		Argid:    id,
		Argparam: param,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] BridgeAPI.Update end")
	}()

	resultBridge, err := t.Internal.Update(ctx, zone, id, param)
	targetResults := struct {
		Bridge *sacloud.Bridge
		Error  error
	}{
		Bridge: resultBridge,
		Error:  err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultBridge, err
}

// Delete is API call with trace log
func (t *BridgeTracer) Delete(ctx context.Context, zone string, id types.ID) error {
	log.Println("[TRACE] BridgeAPI.Delete start")
	targetArguments := struct {
		Argzone string
		Argid   types.ID `json:"id"`
	}{
		Argzone: zone,
		Argid:   id,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] BridgeAPI.Delete end")
	}()

	err := t.Internal.Delete(ctx, zone, id)
	targetResults := struct {
		Error error
	}{
		Error: err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return err
}

/*************************************************
* CDROMTracer
*************************************************/

// CDROMTracer is for trace CDROMOp operations
type CDROMTracer struct {
	Internal sacloud.CDROMAPI
}

// NewCDROMTracer creates new CDROMTracer instance
func NewCDROMTracer(in sacloud.CDROMAPI) sacloud.CDROMAPI {
	return &CDROMTracer{
		Internal: in,
	}
}

// Find is API call with trace log
func (t *CDROMTracer) Find(ctx context.Context, zone string, conditions *sacloud.FindCondition) (*sacloud.CDROMFindResult, error) {
	log.Println("[TRACE] CDROMAPI.Find start")
	targetArguments := struct {
		Argzone       string
		Argconditions *sacloud.FindCondition `json:"conditions"`
	}{
		Argzone:       zone,
		Argconditions: conditions,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] CDROMAPI.Find end")
	}()

	result, err := t.Internal.Find(ctx, zone, conditions)
	targetResults := struct {
		Result *sacloud.CDROMFindResult
		Error  error
	}{
		Result: result,
		Error:  err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return result, err
}

// Create is API call with trace log
func (t *CDROMTracer) Create(ctx context.Context, zone string, param *sacloud.CDROMCreateRequest) (*sacloud.CDROM, *sacloud.FTPServer, error) {
	log.Println("[TRACE] CDROMAPI.Create start")
	targetArguments := struct {
		Argzone  string
		Argparam *sacloud.CDROMCreateRequest `json:"param"`
	}{
		Argzone:  zone,
		Argparam: param,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] CDROMAPI.Create end")
	}()

	resultCDROM, resultFTPServer, err := t.Internal.Create(ctx, zone, param)
	targetResults := struct {
		CDROM     *sacloud.CDROM
		FTPServer *sacloud.FTPServer
		Error     error
	}{
		CDROM:     resultCDROM,
		FTPServer: resultFTPServer,
		Error:     err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultCDROM, resultFTPServer, err
}

// Read is API call with trace log
func (t *CDROMTracer) Read(ctx context.Context, zone string, id types.ID) (*sacloud.CDROM, error) {
	log.Println("[TRACE] CDROMAPI.Read start")
	targetArguments := struct {
		Argzone string
		Argid   types.ID `json:"id"`
	}{
		Argzone: zone,
		Argid:   id,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] CDROMAPI.Read end")
	}()

	resultCDROM, err := t.Internal.Read(ctx, zone, id)
	targetResults := struct {
		CDROM *sacloud.CDROM
		Error error
	}{
		CDROM: resultCDROM,
		Error: err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultCDROM, err
}

// Update is API call with trace log
func (t *CDROMTracer) Update(ctx context.Context, zone string, id types.ID, param *sacloud.CDROMUpdateRequest) (*sacloud.CDROM, error) {
	log.Println("[TRACE] CDROMAPI.Update start")
	targetArguments := struct {
		Argzone  string
		Argid    types.ID                    `json:"id"`
		Argparam *sacloud.CDROMUpdateRequest `json:"param"`
	}{
		Argzone:  zone,
		Argid:    id,
		Argparam: param,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] CDROMAPI.Update end")
	}()

	resultCDROM, err := t.Internal.Update(ctx, zone, id, param)
	targetResults := struct {
		CDROM *sacloud.CDROM
		Error error
	}{
		CDROM: resultCDROM,
		Error: err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultCDROM, err
}

// Delete is API call with trace log
func (t *CDROMTracer) Delete(ctx context.Context, zone string, id types.ID) error {
	log.Println("[TRACE] CDROMAPI.Delete start")
	targetArguments := struct {
		Argzone string
		Argid   types.ID `json:"id"`
	}{
		Argzone: zone,
		Argid:   id,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] CDROMAPI.Delete end")
	}()

	err := t.Internal.Delete(ctx, zone, id)
	targetResults := struct {
		Error error
	}{
		Error: err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return err
}

// OpenFTP is API call with trace log
func (t *CDROMTracer) OpenFTP(ctx context.Context, zone string, id types.ID, openOption *sacloud.OpenFTPRequest) (*sacloud.FTPServer, error) {
	log.Println("[TRACE] CDROMAPI.OpenFTP start")
	targetArguments := struct {
		Argzone       string
		Argid         types.ID                `json:"id"`
		ArgopenOption *sacloud.OpenFTPRequest `json:"openOption"`
	}{
		Argzone:       zone,
		Argid:         id,
		ArgopenOption: openOption,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] CDROMAPI.OpenFTP end")
	}()

	resultFTPServer, err := t.Internal.OpenFTP(ctx, zone, id, openOption)
	targetResults := struct {
		FTPServer *sacloud.FTPServer
		Error     error
	}{
		FTPServer: resultFTPServer,
		Error:     err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultFTPServer, err
}

// CloseFTP is API call with trace log
func (t *CDROMTracer) CloseFTP(ctx context.Context, zone string, id types.ID) error {
	log.Println("[TRACE] CDROMAPI.CloseFTP start")
	targetArguments := struct {
		Argzone string
		Argid   types.ID `json:"id"`
	}{
		Argzone: zone,
		Argid:   id,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] CDROMAPI.CloseFTP end")
	}()

	err := t.Internal.CloseFTP(ctx, zone, id)
	targetResults := struct {
		Error error
	}{
		Error: err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return err
}

/*************************************************
* CertificateAuthorityTracer
*************************************************/

// CertificateAuthorityTracer is for trace CertificateAuthorityOp operations
type CertificateAuthorityTracer struct {
	Internal sacloud.CertificateAuthorityAPI
}

// NewCertificateAuthorityTracer creates new CertificateAuthorityTracer instance
func NewCertificateAuthorityTracer(in sacloud.CertificateAuthorityAPI) sacloud.CertificateAuthorityAPI {
	return &CertificateAuthorityTracer{
		Internal: in,
	}
}

// Find is API call with trace log
func (t *CertificateAuthorityTracer) Find(ctx context.Context, conditions *sacloud.FindCondition) (*sacloud.CertificateAuthorityFindResult, error) {
	log.Println("[TRACE] CertificateAuthorityAPI.Find start")
	targetArguments := struct {
		Argconditions *sacloud.FindCondition `json:"conditions"`
	}{
		Argconditions: conditions,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] CertificateAuthorityAPI.Find end")
	}()

	result, err := t.Internal.Find(ctx, conditions)
	targetResults := struct {
		Result *sacloud.CertificateAuthorityFindResult
		Error  error
	}{
		Result: result,
		Error:  err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return result, err
}

// Create is API call with trace log
func (t *CertificateAuthorityTracer) Create(ctx context.Context, param *sacloud.CertificateAuthorityCreateRequest) (*sacloud.CertificateAuthority, error) {
	log.Println("[TRACE] CertificateAuthorityAPI.Create start")
	targetArguments := struct {
		Argparam *sacloud.CertificateAuthorityCreateRequest `json:"param"`
	}{
		Argparam: param,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] CertificateAuthorityAPI.Create end")
	}()

	resultCertificateAuthority, err := t.Internal.Create(ctx, param)
	targetResults := struct {
		CertificateAuthority *sacloud.CertificateAuthority
		Error                error
	}{
		CertificateAuthority: resultCertificateAuthority,
		Error:                err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultCertificateAuthority, err
}

// Read is API call with trace log
func (t *CertificateAuthorityTracer) Read(ctx context.Context, id types.ID) (*sacloud.CertificateAuthority, error) {
	log.Println("[TRACE] CertificateAuthorityAPI.Read start")
	targetArguments := struct {
		Argid types.ID `json:"id"`
	}{
		Argid: id,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] CertificateAuthorityAPI.Read end")
	}()

	resultCertificateAuthority, err := t.Internal.Read(ctx, id)
	targetResults := struct {
		CertificateAuthority *sacloud.CertificateAuthority
		Error                error
	}{
		CertificateAuthority: resultCertificateAuthority,
		Error:                err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultCertificateAuthority, err
}

// Update is API call with trace log
func (t *CertificateAuthorityTracer) Update(ctx context.Context, id types.ID, param *sacloud.CertificateAuthorityUpdateRequest) (*sacloud.CertificateAuthority, error) {
	log.Println("[TRACE] CertificateAuthorityAPI.Update start")
	targetArguments := struct {
		Argid    types.ID                                   `json:"id"`
		Argparam *sacloud.CertificateAuthorityUpdateRequest `json:"param"`
	}{
		Argid:    id,
		Argparam: param,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] CertificateAuthorityAPI.Update end")
	}()

	resultCertificateAuthority, err := t.Internal.Update(ctx, id, param)
	targetResults := struct {
		CertificateAuthority *sacloud.CertificateAuthority
		Error                error
	}{
		CertificateAuthority: resultCertificateAuthority,
		Error:                err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultCertificateAuthority, err
}

// Delete is API call with trace log
func (t *CertificateAuthorityTracer) Delete(ctx context.Context, id types.ID) error {
	log.Println("[TRACE] CertificateAuthorityAPI.Delete start")
	targetArguments := struct {
		Argid types.ID `json:"id"`
	}{
		Argid: id,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] CertificateAuthorityAPI.Delete end")
	}()

	err := t.Internal.Delete(ctx, id)
	targetResults := struct {
		Error error
	}{
		Error: err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return err
}

// Detail is API call with trace log
func (t *CertificateAuthorityTracer) Detail(ctx context.Context, id types.ID) (*sacloud.CertificateAuthorityDetail, error) {
	log.Println("[TRACE] CertificateAuthorityAPI.Detail start")
	targetArguments := struct {
		Argid types.ID `json:"id"`
	}{
		Argid: id,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] CertificateAuthorityAPI.Detail end")
	}()

	resultCertificateAuthority, err := t.Internal.Detail(ctx, id)
	targetResults := struct {
		CertificateAuthority *sacloud.CertificateAuthorityDetail
		Error                error
	}{
		CertificateAuthority: resultCertificateAuthority,
		Error:                err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultCertificateAuthority, err
}

// AddClient is API call with trace log
func (t *CertificateAuthorityTracer) AddClient(ctx context.Context, id types.ID, param *sacloud.CertificateAuthorityAddClientParam) (*sacloud.CertificateAuthorityAddClientOrServerResult, error) {
	log.Println("[TRACE] CertificateAuthorityAPI.AddClient start")
	targetArguments := struct {
		Argid    types.ID                                    `json:"id"`
		Argparam *sacloud.CertificateAuthorityAddClientParam `json:"param"`
	}{
		Argid:    id,
		Argparam: param,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] CertificateAuthorityAPI.AddClient end")
	}()

	resultCertificateAuthority, err := t.Internal.AddClient(ctx, id, param)
	targetResults := struct {
		CertificateAuthority *sacloud.CertificateAuthorityAddClientOrServerResult
		Error                error
	}{
		CertificateAuthority: resultCertificateAuthority,
		Error:                err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultCertificateAuthority, err
}

// ListClients is API call with trace log
func (t *CertificateAuthorityTracer) ListClients(ctx context.Context, id types.ID) (*sacloud.CertificateAuthorityListClientsResult, error) {
	log.Println("[TRACE] CertificateAuthorityAPI.ListClients start")
	targetArguments := struct {
		Argid types.ID `json:"id"`
	}{
		Argid: id,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] CertificateAuthorityAPI.ListClients end")
	}()

	result, err := t.Internal.ListClients(ctx, id)
	targetResults := struct {
		Result *sacloud.CertificateAuthorityListClientsResult
		Error  error
	}{
		Result: result,
		Error:  err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return result, err
}

// ReadClient is API call with trace log
func (t *CertificateAuthorityTracer) ReadClient(ctx context.Context, id types.ID, clientID string) (*sacloud.CertificateAuthorityClient, error) {
	log.Println("[TRACE] CertificateAuthorityAPI.ReadClient start")
	targetArguments := struct {
		Argid       types.ID `json:"id"`
		ArgclientID string   `json:"clientID"`
	}{
		Argid:       id,
		ArgclientID: clientID,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] CertificateAuthorityAPI.ReadClient end")
	}()

	resultCertificateAuthority, err := t.Internal.ReadClient(ctx, id, clientID)
	targetResults := struct {
		CertificateAuthority *sacloud.CertificateAuthorityClient
		Error                error
	}{
		CertificateAuthority: resultCertificateAuthority,
		Error:                err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultCertificateAuthority, err
}

// RevokeClient is API call with trace log
func (t *CertificateAuthorityTracer) RevokeClient(ctx context.Context, id types.ID, clientID string) error {
	log.Println("[TRACE] CertificateAuthorityAPI.RevokeClient start")
	targetArguments := struct {
		Argid       types.ID `json:"id"`
		ArgclientID string   `json:"clientID"`
	}{
		Argid:       id,
		ArgclientID: clientID,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] CertificateAuthorityAPI.RevokeClient end")
	}()

	err := t.Internal.RevokeClient(ctx, id, clientID)
	targetResults := struct {
		Error error
	}{
		Error: err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return err
}

// HoldClient is API call with trace log
func (t *CertificateAuthorityTracer) HoldClient(ctx context.Context, id types.ID, clientID string) error {
	log.Println("[TRACE] CertificateAuthorityAPI.HoldClient start")
	targetArguments := struct {
		Argid       types.ID `json:"id"`
		ArgclientID string   `json:"clientID"`
	}{
		Argid:       id,
		ArgclientID: clientID,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] CertificateAuthorityAPI.HoldClient end")
	}()

	err := t.Internal.HoldClient(ctx, id, clientID)
	targetResults := struct {
		Error error
	}{
		Error: err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return err
}

// ResumeClient is API call with trace log
func (t *CertificateAuthorityTracer) ResumeClient(ctx context.Context, id types.ID, clientID string) error {
	log.Println("[TRACE] CertificateAuthorityAPI.ResumeClient start")
	targetArguments := struct {
		Argid       types.ID `json:"id"`
		ArgclientID string   `json:"clientID"`
	}{
		Argid:       id,
		ArgclientID: clientID,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] CertificateAuthorityAPI.ResumeClient end")
	}()

	err := t.Internal.ResumeClient(ctx, id, clientID)
	targetResults := struct {
		Error error
	}{
		Error: err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return err
}

// DenyClient is API call with trace log
func (t *CertificateAuthorityTracer) DenyClient(ctx context.Context, id types.ID, clientID string) error {
	log.Println("[TRACE] CertificateAuthorityAPI.DenyClient start")
	targetArguments := struct {
		Argid       types.ID `json:"id"`
		ArgclientID string   `json:"clientID"`
	}{
		Argid:       id,
		ArgclientID: clientID,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] CertificateAuthorityAPI.DenyClient end")
	}()

	err := t.Internal.DenyClient(ctx, id, clientID)
	targetResults := struct {
		Error error
	}{
		Error: err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return err
}

// AddServer is API call with trace log
func (t *CertificateAuthorityTracer) AddServer(ctx context.Context, id types.ID, param *sacloud.CertificateAuthorityAddServerParam) (*sacloud.CertificateAuthorityAddClientOrServerResult, error) {
	log.Println("[TRACE] CertificateAuthorityAPI.AddServer start")
	targetArguments := struct {
		Argid    types.ID                                    `json:"id"`
		Argparam *sacloud.CertificateAuthorityAddServerParam `json:"param"`
	}{
		Argid:    id,
		Argparam: param,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] CertificateAuthorityAPI.AddServer end")
	}()

	resultCertificateAuthority, err := t.Internal.AddServer(ctx, id, param)
	targetResults := struct {
		CertificateAuthority *sacloud.CertificateAuthorityAddClientOrServerResult
		Error                error
	}{
		CertificateAuthority: resultCertificateAuthority,
		Error:                err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultCertificateAuthority, err
}

// ListServers is API call with trace log
func (t *CertificateAuthorityTracer) ListServers(ctx context.Context, id types.ID) (*sacloud.CertificateAuthorityListServersResult, error) {
	log.Println("[TRACE] CertificateAuthorityAPI.ListServers start")
	targetArguments := struct {
		Argid types.ID `json:"id"`
	}{
		Argid: id,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] CertificateAuthorityAPI.ListServers end")
	}()

	result, err := t.Internal.ListServers(ctx, id)
	targetResults := struct {
		Result *sacloud.CertificateAuthorityListServersResult
		Error  error
	}{
		Result: result,
		Error:  err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return result, err
}

// ReadServer is API call with trace log
func (t *CertificateAuthorityTracer) ReadServer(ctx context.Context, id types.ID, serverID string) (*sacloud.CertificateAuthorityServer, error) {
	log.Println("[TRACE] CertificateAuthorityAPI.ReadServer start")
	targetArguments := struct {
		Argid       types.ID `json:"id"`
		ArgserverID string   `json:"serverID"`
	}{
		Argid:       id,
		ArgserverID: serverID,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] CertificateAuthorityAPI.ReadServer end")
	}()

	resultCertificateAuthority, err := t.Internal.ReadServer(ctx, id, serverID)
	targetResults := struct {
		CertificateAuthority *sacloud.CertificateAuthorityServer
		Error                error
	}{
		CertificateAuthority: resultCertificateAuthority,
		Error:                err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultCertificateAuthority, err
}

// RevokeServer is API call with trace log
func (t *CertificateAuthorityTracer) RevokeServer(ctx context.Context, id types.ID, serverID string) error {
	log.Println("[TRACE] CertificateAuthorityAPI.RevokeServer start")
	targetArguments := struct {
		Argid       types.ID `json:"id"`
		ArgserverID string   `json:"serverID"`
	}{
		Argid:       id,
		ArgserverID: serverID,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] CertificateAuthorityAPI.RevokeServer end")
	}()

	err := t.Internal.RevokeServer(ctx, id, serverID)
	targetResults := struct {
		Error error
	}{
		Error: err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return err
}

// HoldServer is API call with trace log
func (t *CertificateAuthorityTracer) HoldServer(ctx context.Context, id types.ID, serverID string) error {
	log.Println("[TRACE] CertificateAuthorityAPI.HoldServer start")
	targetArguments := struct {
		Argid       types.ID `json:"id"`
		ArgserverID string   `json:"serverID"`
	}{
		Argid:       id,
		ArgserverID: serverID,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] CertificateAuthorityAPI.HoldServer end")
	}()

	err := t.Internal.HoldServer(ctx, id, serverID)
	targetResults := struct {
		Error error
	}{
		Error: err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return err
}

// ResumeServer is API call with trace log
func (t *CertificateAuthorityTracer) ResumeServer(ctx context.Context, id types.ID, serverID string) error {
	log.Println("[TRACE] CertificateAuthorityAPI.ResumeServer start")
	targetArguments := struct {
		Argid       types.ID `json:"id"`
		ArgserverID string   `json:"serverID"`
	}{
		Argid:       id,
		ArgserverID: serverID,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] CertificateAuthorityAPI.ResumeServer end")
	}()

	err := t.Internal.ResumeServer(ctx, id, serverID)
	targetResults := struct {
		Error error
	}{
		Error: err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return err
}

/*************************************************
* ContainerRegistryTracer
*************************************************/

// ContainerRegistryTracer is for trace ContainerRegistryOp operations
type ContainerRegistryTracer struct {
	Internal sacloud.ContainerRegistryAPI
}

// NewContainerRegistryTracer creates new ContainerRegistryTracer instance
func NewContainerRegistryTracer(in sacloud.ContainerRegistryAPI) sacloud.ContainerRegistryAPI {
	return &ContainerRegistryTracer{
		Internal: in,
	}
}

// Find is API call with trace log
func (t *ContainerRegistryTracer) Find(ctx context.Context, conditions *sacloud.FindCondition) (*sacloud.ContainerRegistryFindResult, error) {
	log.Println("[TRACE] ContainerRegistryAPI.Find start")
	targetArguments := struct {
		Argconditions *sacloud.FindCondition `json:"conditions"`
	}{
		Argconditions: conditions,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] ContainerRegistryAPI.Find end")
	}()

	result, err := t.Internal.Find(ctx, conditions)
	targetResults := struct {
		Result *sacloud.ContainerRegistryFindResult
		Error  error
	}{
		Result: result,
		Error:  err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return result, err
}

// Create is API call with trace log
func (t *ContainerRegistryTracer) Create(ctx context.Context, param *sacloud.ContainerRegistryCreateRequest) (*sacloud.ContainerRegistry, error) {
	log.Println("[TRACE] ContainerRegistryAPI.Create start")
	targetArguments := struct {
		Argparam *sacloud.ContainerRegistryCreateRequest `json:"param"`
	}{
		Argparam: param,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] ContainerRegistryAPI.Create end")
	}()

	resultContainerRegistry, err := t.Internal.Create(ctx, param)
	targetResults := struct {
		ContainerRegistry *sacloud.ContainerRegistry
		Error             error
	}{
		ContainerRegistry: resultContainerRegistry,
		Error:             err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultContainerRegistry, err
}

// Read is API call with trace log
func (t *ContainerRegistryTracer) Read(ctx context.Context, id types.ID) (*sacloud.ContainerRegistry, error) {
	log.Println("[TRACE] ContainerRegistryAPI.Read start")
	targetArguments := struct {
		Argid types.ID `json:"id"`
	}{
		Argid: id,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] ContainerRegistryAPI.Read end")
	}()

	resultContainerRegistry, err := t.Internal.Read(ctx, id)
	targetResults := struct {
		ContainerRegistry *sacloud.ContainerRegistry
		Error             error
	}{
		ContainerRegistry: resultContainerRegistry,
		Error:             err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultContainerRegistry, err
}

// Update is API call with trace log
func (t *ContainerRegistryTracer) Update(ctx context.Context, id types.ID, param *sacloud.ContainerRegistryUpdateRequest) (*sacloud.ContainerRegistry, error) {
	log.Println("[TRACE] ContainerRegistryAPI.Update start")
	targetArguments := struct {
		Argid    types.ID                                `json:"id"`
		Argparam *sacloud.ContainerRegistryUpdateRequest `json:"param"`
	}{
		Argid:    id,
		Argparam: param,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] ContainerRegistryAPI.Update end")
	}()

	resultContainerRegistry, err := t.Internal.Update(ctx, id, param)
	targetResults := struct {
		ContainerRegistry *sacloud.ContainerRegistry
		Error             error
	}{
		ContainerRegistry: resultContainerRegistry,
		Error:             err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultContainerRegistry, err
}

// UpdateSettings is API call with trace log
func (t *ContainerRegistryTracer) UpdateSettings(ctx context.Context, id types.ID, param *sacloud.ContainerRegistryUpdateSettingsRequest) (*sacloud.ContainerRegistry, error) {
	log.Println("[TRACE] ContainerRegistryAPI.UpdateSettings start")
	targetArguments := struct {
		Argid    types.ID                                        `json:"id"`
		Argparam *sacloud.ContainerRegistryUpdateSettingsRequest `json:"param"`
	}{
		Argid:    id,
		Argparam: param,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] ContainerRegistryAPI.UpdateSettings end")
	}()

	resultContainerRegistry, err := t.Internal.UpdateSettings(ctx, id, param)
	targetResults := struct {
		ContainerRegistry *sacloud.ContainerRegistry
		Error             error
	}{
		ContainerRegistry: resultContainerRegistry,
		Error:             err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultContainerRegistry, err
}

// Delete is API call with trace log
func (t *ContainerRegistryTracer) Delete(ctx context.Context, id types.ID) error {
	log.Println("[TRACE] ContainerRegistryAPI.Delete start")
	targetArguments := struct {
		Argid types.ID `json:"id"`
	}{
		Argid: id,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] ContainerRegistryAPI.Delete end")
	}()

	err := t.Internal.Delete(ctx, id)
	targetResults := struct {
		Error error
	}{
		Error: err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return err
}

// ListUsers is API call with trace log
func (t *ContainerRegistryTracer) ListUsers(ctx context.Context, id types.ID) (*sacloud.ContainerRegistryUsers, error) {
	log.Println("[TRACE] ContainerRegistryAPI.ListUsers start")
	targetArguments := struct {
		Argid types.ID `json:"id"`
	}{
		Argid: id,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] ContainerRegistryAPI.ListUsers end")
	}()

	resultContainerRegistryUsers, err := t.Internal.ListUsers(ctx, id)
	targetResults := struct {
		ContainerRegistryUsers *sacloud.ContainerRegistryUsers
		Error                  error
	}{
		ContainerRegistryUsers: resultContainerRegistryUsers,
		Error:                  err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultContainerRegistryUsers, err
}

// AddUser is API call with trace log
func (t *ContainerRegistryTracer) AddUser(ctx context.Context, id types.ID, param *sacloud.ContainerRegistryUserCreateRequest) error {
	log.Println("[TRACE] ContainerRegistryAPI.AddUser start")
	targetArguments := struct {
		Argid    types.ID                                    `json:"id"`
		Argparam *sacloud.ContainerRegistryUserCreateRequest `json:"param"`
	}{
		Argid:    id,
		Argparam: param,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] ContainerRegistryAPI.AddUser end")
	}()

	err := t.Internal.AddUser(ctx, id, param)
	targetResults := struct {
		Error error
	}{
		Error: err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return err
}

// UpdateUser is API call with trace log
func (t *ContainerRegistryTracer) UpdateUser(ctx context.Context, id types.ID, username string, param *sacloud.ContainerRegistryUserUpdateRequest) error {
	log.Println("[TRACE] ContainerRegistryAPI.UpdateUser start")
	targetArguments := struct {
		Argid       types.ID                                    `json:"id"`
		Argusername string                                      `json:"username"`
		Argparam    *sacloud.ContainerRegistryUserUpdateRequest `json:"param"`
	}{
		Argid:       id,
		Argusername: username,
		Argparam:    param,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] ContainerRegistryAPI.UpdateUser end")
	}()

	err := t.Internal.UpdateUser(ctx, id, username, param)
	targetResults := struct {
		Error error
	}{
		Error: err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return err
}

// DeleteUser is API call with trace log
func (t *ContainerRegistryTracer) DeleteUser(ctx context.Context, id types.ID, username string) error {
	log.Println("[TRACE] ContainerRegistryAPI.DeleteUser start")
	targetArguments := struct {
		Argid       types.ID `json:"id"`
		Argusername string   `json:"username"`
	}{
		Argid:       id,
		Argusername: username,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] ContainerRegistryAPI.DeleteUser end")
	}()

	err := t.Internal.DeleteUser(ctx, id, username)
	targetResults := struct {
		Error error
	}{
		Error: err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return err
}

/*************************************************
* CouponTracer
*************************************************/

// CouponTracer is for trace CouponOp operations
type CouponTracer struct {
	Internal sacloud.CouponAPI
}

// NewCouponTracer creates new CouponTracer instance
func NewCouponTracer(in sacloud.CouponAPI) sacloud.CouponAPI {
	return &CouponTracer{
		Internal: in,
	}
}

// Find is API call with trace log
func (t *CouponTracer) Find(ctx context.Context, accountID types.ID) (*sacloud.CouponFindResult, error) {
	log.Println("[TRACE] CouponAPI.Find start")
	targetArguments := struct {
		ArgaccountID types.ID `json:"accountID"`
	}{
		ArgaccountID: accountID,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] CouponAPI.Find end")
	}()

	result, err := t.Internal.Find(ctx, accountID)
	targetResults := struct {
		Result *sacloud.CouponFindResult
		Error  error
	}{
		Result: result,
		Error:  err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return result, err
}

/*************************************************
* DatabaseTracer
*************************************************/

// DatabaseTracer is for trace DatabaseOp operations
type DatabaseTracer struct {
	Internal sacloud.DatabaseAPI
}

// NewDatabaseTracer creates new DatabaseTracer instance
func NewDatabaseTracer(in sacloud.DatabaseAPI) sacloud.DatabaseAPI {
	return &DatabaseTracer{
		Internal: in,
	}
}

// Find is API call with trace log
func (t *DatabaseTracer) Find(ctx context.Context, zone string, conditions *sacloud.FindCondition) (*sacloud.DatabaseFindResult, error) {
	log.Println("[TRACE] DatabaseAPI.Find start")
	targetArguments := struct {
		Argzone       string
		Argconditions *sacloud.FindCondition `json:"conditions"`
	}{
		Argzone:       zone,
		Argconditions: conditions,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] DatabaseAPI.Find end")
	}()

	result, err := t.Internal.Find(ctx, zone, conditions)
	targetResults := struct {
		Result *sacloud.DatabaseFindResult
		Error  error
	}{
		Result: result,
		Error:  err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return result, err
}

// Create is API call with trace log
func (t *DatabaseTracer) Create(ctx context.Context, zone string, param *sacloud.DatabaseCreateRequest) (*sacloud.Database, error) {
	log.Println("[TRACE] DatabaseAPI.Create start")
	targetArguments := struct {
		Argzone  string
		Argparam *sacloud.DatabaseCreateRequest `json:"param"`
	}{
		Argzone:  zone,
		Argparam: param,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] DatabaseAPI.Create end")
	}()

	resultDatabase, err := t.Internal.Create(ctx, zone, param)
	targetResults := struct {
		Database *sacloud.Database
		Error    error
	}{
		Database: resultDatabase,
		Error:    err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultDatabase, err
}

// Read is API call with trace log
func (t *DatabaseTracer) Read(ctx context.Context, zone string, id types.ID) (*sacloud.Database, error) {
	log.Println("[TRACE] DatabaseAPI.Read start")
	targetArguments := struct {
		Argzone string
		Argid   types.ID `json:"id"`
	}{
		Argzone: zone,
		Argid:   id,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] DatabaseAPI.Read end")
	}()

	resultDatabase, err := t.Internal.Read(ctx, zone, id)
	targetResults := struct {
		Database *sacloud.Database
		Error    error
	}{
		Database: resultDatabase,
		Error:    err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultDatabase, err
}

// Update is API call with trace log
func (t *DatabaseTracer) Update(ctx context.Context, zone string, id types.ID, param *sacloud.DatabaseUpdateRequest) (*sacloud.Database, error) {
	log.Println("[TRACE] DatabaseAPI.Update start")
	targetArguments := struct {
		Argzone  string
		Argid    types.ID                       `json:"id"`
		Argparam *sacloud.DatabaseUpdateRequest `json:"param"`
	}{
		Argzone:  zone,
		Argid:    id,
		Argparam: param,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] DatabaseAPI.Update end")
	}()

	resultDatabase, err := t.Internal.Update(ctx, zone, id, param)
	targetResults := struct {
		Database *sacloud.Database
		Error    error
	}{
		Database: resultDatabase,
		Error:    err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultDatabase, err
}

// UpdateSettings is API call with trace log
func (t *DatabaseTracer) UpdateSettings(ctx context.Context, zone string, id types.ID, param *sacloud.DatabaseUpdateSettingsRequest) (*sacloud.Database, error) {
	log.Println("[TRACE] DatabaseAPI.UpdateSettings start")
	targetArguments := struct {
		Argzone  string
		Argid    types.ID                               `json:"id"`
		Argparam *sacloud.DatabaseUpdateSettingsRequest `json:"param"`
	}{
		Argzone:  zone,
		Argid:    id,
		Argparam: param,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] DatabaseAPI.UpdateSettings end")
	}()

	resultDatabase, err := t.Internal.UpdateSettings(ctx, zone, id, param)
	targetResults := struct {
		Database *sacloud.Database
		Error    error
	}{
		Database: resultDatabase,
		Error:    err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultDatabase, err
}

// Delete is API call with trace log
func (t *DatabaseTracer) Delete(ctx context.Context, zone string, id types.ID) error {
	log.Println("[TRACE] DatabaseAPI.Delete start")
	targetArguments := struct {
		Argzone string
		Argid   types.ID `json:"id"`
	}{
		Argzone: zone,
		Argid:   id,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] DatabaseAPI.Delete end")
	}()

	err := t.Internal.Delete(ctx, zone, id)
	targetResults := struct {
		Error error
	}{
		Error: err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return err
}

// Config is API call with trace log
func (t *DatabaseTracer) Config(ctx context.Context, zone string, id types.ID) error {
	log.Println("[TRACE] DatabaseAPI.Config start")
	targetArguments := struct {
		Argzone string
		Argid   types.ID `json:"id"`
	}{
		Argzone: zone,
		Argid:   id,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] DatabaseAPI.Config end")
	}()

	err := t.Internal.Config(ctx, zone, id)
	targetResults := struct {
		Error error
	}{
		Error: err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return err
}

// Boot is API call with trace log
func (t *DatabaseTracer) Boot(ctx context.Context, zone string, id types.ID) error {
	log.Println("[TRACE] DatabaseAPI.Boot start")
	targetArguments := struct {
		Argzone string
		Argid   types.ID `json:"id"`
	}{
		Argzone: zone,
		Argid:   id,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] DatabaseAPI.Boot end")
	}()

	err := t.Internal.Boot(ctx, zone, id)
	targetResults := struct {
		Error error
	}{
		Error: err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return err
}

// Shutdown is API call with trace log
func (t *DatabaseTracer) Shutdown(ctx context.Context, zone string, id types.ID, shutdownOption *sacloud.ShutdownOption) error {
	log.Println("[TRACE] DatabaseAPI.Shutdown start")
	targetArguments := struct {
		Argzone           string
		Argid             types.ID                `json:"id"`
		ArgshutdownOption *sacloud.ShutdownOption `json:"shutdownOption"`
	}{
		Argzone:           zone,
		Argid:             id,
		ArgshutdownOption: shutdownOption,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] DatabaseAPI.Shutdown end")
	}()

	err := t.Internal.Shutdown(ctx, zone, id, shutdownOption)
	targetResults := struct {
		Error error
	}{
		Error: err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return err
}

// Reset is API call with trace log
func (t *DatabaseTracer) Reset(ctx context.Context, zone string, id types.ID) error {
	log.Println("[TRACE] DatabaseAPI.Reset start")
	targetArguments := struct {
		Argzone string
		Argid   types.ID `json:"id"`
	}{
		Argzone: zone,
		Argid:   id,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] DatabaseAPI.Reset end")
	}()

	err := t.Internal.Reset(ctx, zone, id)
	targetResults := struct {
		Error error
	}{
		Error: err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return err
}

// MonitorCPU is API call with trace log
func (t *DatabaseTracer) MonitorCPU(ctx context.Context, zone string, id types.ID, condition *sacloud.MonitorCondition) (*sacloud.CPUTimeActivity, error) {
	log.Println("[TRACE] DatabaseAPI.MonitorCPU start")
	targetArguments := struct {
		Argzone      string
		Argid        types.ID                  `json:"id"`
		Argcondition *sacloud.MonitorCondition `json:"condition"`
	}{
		Argzone:      zone,
		Argid:        id,
		Argcondition: condition,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] DatabaseAPI.MonitorCPU end")
	}()

	resultCPUTimeActivity, err := t.Internal.MonitorCPU(ctx, zone, id, condition)
	targetResults := struct {
		CPUTimeActivity *sacloud.CPUTimeActivity
		Error           error
	}{
		CPUTimeActivity: resultCPUTimeActivity,
		Error:           err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultCPUTimeActivity, err
}

// MonitorDisk is API call with trace log
func (t *DatabaseTracer) MonitorDisk(ctx context.Context, zone string, id types.ID, condition *sacloud.MonitorCondition) (*sacloud.DiskActivity, error) {
	log.Println("[TRACE] DatabaseAPI.MonitorDisk start")
	targetArguments := struct {
		Argzone      string
		Argid        types.ID                  `json:"id"`
		Argcondition *sacloud.MonitorCondition `json:"condition"`
	}{
		Argzone:      zone,
		Argid:        id,
		Argcondition: condition,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] DatabaseAPI.MonitorDisk end")
	}()

	resultDiskActivity, err := t.Internal.MonitorDisk(ctx, zone, id, condition)
	targetResults := struct {
		DiskActivity *sacloud.DiskActivity
		Error        error
	}{
		DiskActivity: resultDiskActivity,
		Error:        err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultDiskActivity, err
}

// MonitorInterface is API call with trace log
func (t *DatabaseTracer) MonitorInterface(ctx context.Context, zone string, id types.ID, condition *sacloud.MonitorCondition) (*sacloud.InterfaceActivity, error) {
	log.Println("[TRACE] DatabaseAPI.MonitorInterface start")
	targetArguments := struct {
		Argzone      string
		Argid        types.ID                  `json:"id"`
		Argcondition *sacloud.MonitorCondition `json:"condition"`
	}{
		Argzone:      zone,
		Argid:        id,
		Argcondition: condition,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] DatabaseAPI.MonitorInterface end")
	}()

	resultInterfaceActivity, err := t.Internal.MonitorInterface(ctx, zone, id, condition)
	targetResults := struct {
		InterfaceActivity *sacloud.InterfaceActivity
		Error             error
	}{
		InterfaceActivity: resultInterfaceActivity,
		Error:             err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultInterfaceActivity, err
}

// MonitorDatabase is API call with trace log
func (t *DatabaseTracer) MonitorDatabase(ctx context.Context, zone string, id types.ID, condition *sacloud.MonitorCondition) (*sacloud.DatabaseActivity, error) {
	log.Println("[TRACE] DatabaseAPI.MonitorDatabase start")
	targetArguments := struct {
		Argzone      string
		Argid        types.ID                  `json:"id"`
		Argcondition *sacloud.MonitorCondition `json:"condition"`
	}{
		Argzone:      zone,
		Argid:        id,
		Argcondition: condition,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] DatabaseAPI.MonitorDatabase end")
	}()

	resultDatabaseActivity, err := t.Internal.MonitorDatabase(ctx, zone, id, condition)
	targetResults := struct {
		DatabaseActivity *sacloud.DatabaseActivity
		Error            error
	}{
		DatabaseActivity: resultDatabaseActivity,
		Error:            err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultDatabaseActivity, err
}

// Status is API call with trace log
func (t *DatabaseTracer) Status(ctx context.Context, zone string, id types.ID) (*sacloud.DatabaseStatus, error) {
	log.Println("[TRACE] DatabaseAPI.Status start")
	targetArguments := struct {
		Argzone string
		Argid   types.ID `json:"id"`
	}{
		Argzone: zone,
		Argid:   id,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] DatabaseAPI.Status end")
	}()

	resultDatabaseStatus, err := t.Internal.Status(ctx, zone, id)
	targetResults := struct {
		DatabaseStatus *sacloud.DatabaseStatus
		Error          error
	}{
		DatabaseStatus: resultDatabaseStatus,
		Error:          err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultDatabaseStatus, err
}

// GetParameter is API call with trace log
func (t *DatabaseTracer) GetParameter(ctx context.Context, zone string, id types.ID) (*sacloud.DatabaseParameter, error) {
	log.Println("[TRACE] DatabaseAPI.GetParameter start")
	targetArguments := struct {
		Argzone string
		Argid   types.ID `json:"id"`
	}{
		Argzone: zone,
		Argid:   id,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] DatabaseAPI.GetParameter end")
	}()

	resultDatabaseParameter, err := t.Internal.GetParameter(ctx, zone, id)
	targetResults := struct {
		DatabaseParameter *sacloud.DatabaseParameter
		Error             error
	}{
		DatabaseParameter: resultDatabaseParameter,
		Error:             err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultDatabaseParameter, err
}

// SetParameter is API call with trace log
func (t *DatabaseTracer) SetParameter(ctx context.Context, zone string, id types.ID, param map[string]interface{}) error {
	log.Println("[TRACE] DatabaseAPI.SetParameter start")
	targetArguments := struct {
		Argzone  string
		Argid    types.ID               `json:"id"`
		Argparam map[string]interface{} `json:"param"`
	}{
		Argzone:  zone,
		Argid:    id,
		Argparam: param,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] DatabaseAPI.SetParameter end")
	}()

	err := t.Internal.SetParameter(ctx, zone, id, param)
	targetResults := struct {
		Error error
	}{
		Error: err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return err
}

/*************************************************
* DiskTracer
*************************************************/

// DiskTracer is for trace DiskOp operations
type DiskTracer struct {
	Internal sacloud.DiskAPI
}

// NewDiskTracer creates new DiskTracer instance
func NewDiskTracer(in sacloud.DiskAPI) sacloud.DiskAPI {
	return &DiskTracer{
		Internal: in,
	}
}

// Find is API call with trace log
func (t *DiskTracer) Find(ctx context.Context, zone string, conditions *sacloud.FindCondition) (*sacloud.DiskFindResult, error) {
	log.Println("[TRACE] DiskAPI.Find start")
	targetArguments := struct {
		Argzone       string
		Argconditions *sacloud.FindCondition `json:"conditions"`
	}{
		Argzone:       zone,
		Argconditions: conditions,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] DiskAPI.Find end")
	}()

	result, err := t.Internal.Find(ctx, zone, conditions)
	targetResults := struct {
		Result *sacloud.DiskFindResult
		Error  error
	}{
		Result: result,
		Error:  err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return result, err
}

// Create is API call with trace log
func (t *DiskTracer) Create(ctx context.Context, zone string, createParam *sacloud.DiskCreateRequest, distantFrom []types.ID) (*sacloud.Disk, error) {
	log.Println("[TRACE] DiskAPI.Create start")
	targetArguments := struct {
		Argzone        string
		ArgcreateParam *sacloud.DiskCreateRequest `json:"createParam"`
		ArgdistantFrom []types.ID                 `json:"distantFrom"`
	}{
		Argzone:        zone,
		ArgcreateParam: createParam,
		ArgdistantFrom: distantFrom,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] DiskAPI.Create end")
	}()

	resultDisk, err := t.Internal.Create(ctx, zone, createParam, distantFrom)
	targetResults := struct {
		Disk  *sacloud.Disk
		Error error
	}{
		Disk:  resultDisk,
		Error: err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultDisk, err
}

// Config is API call with trace log
func (t *DiskTracer) Config(ctx context.Context, zone string, id types.ID, edit *sacloud.DiskEditRequest) error {
	log.Println("[TRACE] DiskAPI.Config start")
	targetArguments := struct {
		Argzone string
		Argid   types.ID                 `json:"id"`
		Argedit *sacloud.DiskEditRequest `json:"edit"`
	}{
		Argzone: zone,
		Argid:   id,
		Argedit: edit,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] DiskAPI.Config end")
	}()

	err := t.Internal.Config(ctx, zone, id, edit)
	targetResults := struct {
		Error error
	}{
		Error: err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return err
}

// CreateWithConfig is API call with trace log
func (t *DiskTracer) CreateWithConfig(ctx context.Context, zone string, createParam *sacloud.DiskCreateRequest, editParam *sacloud.DiskEditRequest, bootAtAvailable bool, distantFrom []types.ID) (*sacloud.Disk, error) {
	log.Println("[TRACE] DiskAPI.CreateWithConfig start")
	targetArguments := struct {
		Argzone            string
		ArgcreateParam     *sacloud.DiskCreateRequest `json:"createParam"`
		ArgeditParam       *sacloud.DiskEditRequest   `json:"editParam"`
		ArgbootAtAvailable bool                       `json:"bootAtAvailable"`
		ArgdistantFrom     []types.ID                 `json:"distantFrom"`
	}{
		Argzone:            zone,
		ArgcreateParam:     createParam,
		ArgeditParam:       editParam,
		ArgbootAtAvailable: bootAtAvailable,
		ArgdistantFrom:     distantFrom,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] DiskAPI.CreateWithConfig end")
	}()

	resultDisk, err := t.Internal.CreateWithConfig(ctx, zone, createParam, editParam, bootAtAvailable, distantFrom)
	targetResults := struct {
		Disk  *sacloud.Disk
		Error error
	}{
		Disk:  resultDisk,
		Error: err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultDisk, err
}

// ResizePartition is API call with trace log
func (t *DiskTracer) ResizePartition(ctx context.Context, zone string, id types.ID, param *sacloud.DiskResizePartitionRequest) error {
	log.Println("[TRACE] DiskAPI.ResizePartition start")
	targetArguments := struct {
		Argzone  string
		Argid    types.ID                            `json:"id"`
		Argparam *sacloud.DiskResizePartitionRequest `json:"param"`
	}{
		Argzone:  zone,
		Argid:    id,
		Argparam: param,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] DiskAPI.ResizePartition end")
	}()

	err := t.Internal.ResizePartition(ctx, zone, id, param)
	targetResults := struct {
		Error error
	}{
		Error: err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return err
}

// ConnectToServer is API call with trace log
func (t *DiskTracer) ConnectToServer(ctx context.Context, zone string, id types.ID, serverID types.ID) error {
	log.Println("[TRACE] DiskAPI.ConnectToServer start")
	targetArguments := struct {
		Argzone     string
		Argid       types.ID `json:"id"`
		ArgserverID types.ID `json:"serverID"`
	}{
		Argzone:     zone,
		Argid:       id,
		ArgserverID: serverID,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] DiskAPI.ConnectToServer end")
	}()

	err := t.Internal.ConnectToServer(ctx, zone, id, serverID)
	targetResults := struct {
		Error error
	}{
		Error: err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return err
}

// DisconnectFromServer is API call with trace log
func (t *DiskTracer) DisconnectFromServer(ctx context.Context, zone string, id types.ID) error {
	log.Println("[TRACE] DiskAPI.DisconnectFromServer start")
	targetArguments := struct {
		Argzone string
		Argid   types.ID `json:"id"`
	}{
		Argzone: zone,
		Argid:   id,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] DiskAPI.DisconnectFromServer end")
	}()

	err := t.Internal.DisconnectFromServer(ctx, zone, id)
	targetResults := struct {
		Error error
	}{
		Error: err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return err
}

// Read is API call with trace log
func (t *DiskTracer) Read(ctx context.Context, zone string, id types.ID) (*sacloud.Disk, error) {
	log.Println("[TRACE] DiskAPI.Read start")
	targetArguments := struct {
		Argzone string
		Argid   types.ID `json:"id"`
	}{
		Argzone: zone,
		Argid:   id,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] DiskAPI.Read end")
	}()

	resultDisk, err := t.Internal.Read(ctx, zone, id)
	targetResults := struct {
		Disk  *sacloud.Disk
		Error error
	}{
		Disk:  resultDisk,
		Error: err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultDisk, err
}

// Update is API call with trace log
func (t *DiskTracer) Update(ctx context.Context, zone string, id types.ID, param *sacloud.DiskUpdateRequest) (*sacloud.Disk, error) {
	log.Println("[TRACE] DiskAPI.Update start")
	targetArguments := struct {
		Argzone  string
		Argid    types.ID                   `json:"id"`
		Argparam *sacloud.DiskUpdateRequest `json:"param"`
	}{
		Argzone:  zone,
		Argid:    id,
		Argparam: param,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] DiskAPI.Update end")
	}()

	resultDisk, err := t.Internal.Update(ctx, zone, id, param)
	targetResults := struct {
		Disk  *sacloud.Disk
		Error error
	}{
		Disk:  resultDisk,
		Error: err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultDisk, err
}

// Delete is API call with trace log
func (t *DiskTracer) Delete(ctx context.Context, zone string, id types.ID) error {
	log.Println("[TRACE] DiskAPI.Delete start")
	targetArguments := struct {
		Argzone string
		Argid   types.ID `json:"id"`
	}{
		Argzone: zone,
		Argid:   id,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] DiskAPI.Delete end")
	}()

	err := t.Internal.Delete(ctx, zone, id)
	targetResults := struct {
		Error error
	}{
		Error: err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return err
}

// Monitor is API call with trace log
func (t *DiskTracer) Monitor(ctx context.Context, zone string, id types.ID, condition *sacloud.MonitorCondition) (*sacloud.DiskActivity, error) {
	log.Println("[TRACE] DiskAPI.Monitor start")
	targetArguments := struct {
		Argzone      string
		Argid        types.ID                  `json:"id"`
		Argcondition *sacloud.MonitorCondition `json:"condition"`
	}{
		Argzone:      zone,
		Argid:        id,
		Argcondition: condition,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] DiskAPI.Monitor end")
	}()

	resultDiskActivity, err := t.Internal.Monitor(ctx, zone, id, condition)
	targetResults := struct {
		DiskActivity *sacloud.DiskActivity
		Error        error
	}{
		DiskActivity: resultDiskActivity,
		Error:        err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultDiskActivity, err
}

// MonitorDisk is API call with trace log
func (t *DiskTracer) MonitorDisk(ctx context.Context, zone string, id types.ID, condition *sacloud.MonitorCondition) (*sacloud.DiskActivity, error) {
	log.Println("[TRACE] DiskAPI.MonitorDisk start")
	targetArguments := struct {
		Argzone      string
		Argid        types.ID                  `json:"id"`
		Argcondition *sacloud.MonitorCondition `json:"condition"`
	}{
		Argzone:      zone,
		Argid:        id,
		Argcondition: condition,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] DiskAPI.MonitorDisk end")
	}()

	resultDiskActivity, err := t.Internal.MonitorDisk(ctx, zone, id, condition)
	targetResults := struct {
		DiskActivity *sacloud.DiskActivity
		Error        error
	}{
		DiskActivity: resultDiskActivity,
		Error:        err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultDiskActivity, err
}

/*************************************************
* DiskPlanTracer
*************************************************/

// DiskPlanTracer is for trace DiskPlanOp operations
type DiskPlanTracer struct {
	Internal sacloud.DiskPlanAPI
}

// NewDiskPlanTracer creates new DiskPlanTracer instance
func NewDiskPlanTracer(in sacloud.DiskPlanAPI) sacloud.DiskPlanAPI {
	return &DiskPlanTracer{
		Internal: in,
	}
}

// Find is API call with trace log
func (t *DiskPlanTracer) Find(ctx context.Context, zone string, conditions *sacloud.FindCondition) (*sacloud.DiskPlanFindResult, error) {
	log.Println("[TRACE] DiskPlanAPI.Find start")
	targetArguments := struct {
		Argzone       string
		Argconditions *sacloud.FindCondition `json:"conditions"`
	}{
		Argzone:       zone,
		Argconditions: conditions,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] DiskPlanAPI.Find end")
	}()

	result, err := t.Internal.Find(ctx, zone, conditions)
	targetResults := struct {
		Result *sacloud.DiskPlanFindResult
		Error  error
	}{
		Result: result,
		Error:  err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return result, err
}

// Read is API call with trace log
func (t *DiskPlanTracer) Read(ctx context.Context, zone string, id types.ID) (*sacloud.DiskPlan, error) {
	log.Println("[TRACE] DiskPlanAPI.Read start")
	targetArguments := struct {
		Argzone string
		Argid   types.ID `json:"id"`
	}{
		Argzone: zone,
		Argid:   id,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] DiskPlanAPI.Read end")
	}()

	resultDiskPlan, err := t.Internal.Read(ctx, zone, id)
	targetResults := struct {
		DiskPlan *sacloud.DiskPlan
		Error    error
	}{
		DiskPlan: resultDiskPlan,
		Error:    err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultDiskPlan, err
}

/*************************************************
* DNSTracer
*************************************************/

// DNSTracer is for trace DNSOp operations
type DNSTracer struct {
	Internal sacloud.DNSAPI
}

// NewDNSTracer creates new DNSTracer instance
func NewDNSTracer(in sacloud.DNSAPI) sacloud.DNSAPI {
	return &DNSTracer{
		Internal: in,
	}
}

// Find is API call with trace log
func (t *DNSTracer) Find(ctx context.Context, conditions *sacloud.FindCondition) (*sacloud.DNSFindResult, error) {
	log.Println("[TRACE] DNSAPI.Find start")
	targetArguments := struct {
		Argconditions *sacloud.FindCondition `json:"conditions"`
	}{
		Argconditions: conditions,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] DNSAPI.Find end")
	}()

	result, err := t.Internal.Find(ctx, conditions)
	targetResults := struct {
		Result *sacloud.DNSFindResult
		Error  error
	}{
		Result: result,
		Error:  err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return result, err
}

// Create is API call with trace log
func (t *DNSTracer) Create(ctx context.Context, param *sacloud.DNSCreateRequest) (*sacloud.DNS, error) {
	log.Println("[TRACE] DNSAPI.Create start")
	targetArguments := struct {
		Argparam *sacloud.DNSCreateRequest `json:"param"`
	}{
		Argparam: param,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] DNSAPI.Create end")
	}()

	resultDNS, err := t.Internal.Create(ctx, param)
	targetResults := struct {
		DNS   *sacloud.DNS
		Error error
	}{
		DNS:   resultDNS,
		Error: err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultDNS, err
}

// Read is API call with trace log
func (t *DNSTracer) Read(ctx context.Context, id types.ID) (*sacloud.DNS, error) {
	log.Println("[TRACE] DNSAPI.Read start")
	targetArguments := struct {
		Argid types.ID `json:"id"`
	}{
		Argid: id,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] DNSAPI.Read end")
	}()

	resultDNS, err := t.Internal.Read(ctx, id)
	targetResults := struct {
		DNS   *sacloud.DNS
		Error error
	}{
		DNS:   resultDNS,
		Error: err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultDNS, err
}

// Update is API call with trace log
func (t *DNSTracer) Update(ctx context.Context, id types.ID, param *sacloud.DNSUpdateRequest) (*sacloud.DNS, error) {
	log.Println("[TRACE] DNSAPI.Update start")
	targetArguments := struct {
		Argid    types.ID                  `json:"id"`
		Argparam *sacloud.DNSUpdateRequest `json:"param"`
	}{
		Argid:    id,
		Argparam: param,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] DNSAPI.Update end")
	}()

	resultDNS, err := t.Internal.Update(ctx, id, param)
	targetResults := struct {
		DNS   *sacloud.DNS
		Error error
	}{
		DNS:   resultDNS,
		Error: err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultDNS, err
}

// UpdateSettings is API call with trace log
func (t *DNSTracer) UpdateSettings(ctx context.Context, id types.ID, param *sacloud.DNSUpdateSettingsRequest) (*sacloud.DNS, error) {
	log.Println("[TRACE] DNSAPI.UpdateSettings start")
	targetArguments := struct {
		Argid    types.ID                          `json:"id"`
		Argparam *sacloud.DNSUpdateSettingsRequest `json:"param"`
	}{
		Argid:    id,
		Argparam: param,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] DNSAPI.UpdateSettings end")
	}()

	resultDNS, err := t.Internal.UpdateSettings(ctx, id, param)
	targetResults := struct {
		DNS   *sacloud.DNS
		Error error
	}{
		DNS:   resultDNS,
		Error: err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultDNS, err
}

// Delete is API call with trace log
func (t *DNSTracer) Delete(ctx context.Context, id types.ID) error {
	log.Println("[TRACE] DNSAPI.Delete start")
	targetArguments := struct {
		Argid types.ID `json:"id"`
	}{
		Argid: id,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] DNSAPI.Delete end")
	}()

	err := t.Internal.Delete(ctx, id)
	targetResults := struct {
		Error error
	}{
		Error: err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return err
}

/*************************************************
* EnhancedDBTracer
*************************************************/

// EnhancedDBTracer is for trace EnhancedDBOp operations
type EnhancedDBTracer struct {
	Internal sacloud.EnhancedDBAPI
}

// NewEnhancedDBTracer creates new EnhancedDBTracer instance
func NewEnhancedDBTracer(in sacloud.EnhancedDBAPI) sacloud.EnhancedDBAPI {
	return &EnhancedDBTracer{
		Internal: in,
	}
}

// Find is API call with trace log
func (t *EnhancedDBTracer) Find(ctx context.Context, conditions *sacloud.FindCondition) (*sacloud.EnhancedDBFindResult, error) {
	log.Println("[TRACE] EnhancedDBAPI.Find start")
	targetArguments := struct {
		Argconditions *sacloud.FindCondition `json:"conditions"`
	}{
		Argconditions: conditions,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] EnhancedDBAPI.Find end")
	}()

	result, err := t.Internal.Find(ctx, conditions)
	targetResults := struct {
		Result *sacloud.EnhancedDBFindResult
		Error  error
	}{
		Result: result,
		Error:  err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return result, err
}

// Create is API call with trace log
func (t *EnhancedDBTracer) Create(ctx context.Context, param *sacloud.EnhancedDBCreateRequest) (*sacloud.EnhancedDB, error) {
	log.Println("[TRACE] EnhancedDBAPI.Create start")
	targetArguments := struct {
		Argparam *sacloud.EnhancedDBCreateRequest `json:"param"`
	}{
		Argparam: param,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] EnhancedDBAPI.Create end")
	}()

	resultEnhancedDB, err := t.Internal.Create(ctx, param)
	targetResults := struct {
		EnhancedDB *sacloud.EnhancedDB
		Error      error
	}{
		EnhancedDB: resultEnhancedDB,
		Error:      err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultEnhancedDB, err
}

// Read is API call with trace log
func (t *EnhancedDBTracer) Read(ctx context.Context, id types.ID) (*sacloud.EnhancedDB, error) {
	log.Println("[TRACE] EnhancedDBAPI.Read start")
	targetArguments := struct {
		Argid types.ID `json:"id"`
	}{
		Argid: id,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] EnhancedDBAPI.Read end")
	}()

	resultEnhancedDB, err := t.Internal.Read(ctx, id)
	targetResults := struct {
		EnhancedDB *sacloud.EnhancedDB
		Error      error
	}{
		EnhancedDB: resultEnhancedDB,
		Error:      err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultEnhancedDB, err
}

// Update is API call with trace log
func (t *EnhancedDBTracer) Update(ctx context.Context, id types.ID, param *sacloud.EnhancedDBUpdateRequest) (*sacloud.EnhancedDB, error) {
	log.Println("[TRACE] EnhancedDBAPI.Update start")
	targetArguments := struct {
		Argid    types.ID                         `json:"id"`
		Argparam *sacloud.EnhancedDBUpdateRequest `json:"param"`
	}{
		Argid:    id,
		Argparam: param,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] EnhancedDBAPI.Update end")
	}()

	resultEnhancedDB, err := t.Internal.Update(ctx, id, param)
	targetResults := struct {
		EnhancedDB *sacloud.EnhancedDB
		Error      error
	}{
		EnhancedDB: resultEnhancedDB,
		Error:      err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultEnhancedDB, err
}

// Delete is API call with trace log
func (t *EnhancedDBTracer) Delete(ctx context.Context, id types.ID) error {
	log.Println("[TRACE] EnhancedDBAPI.Delete start")
	targetArguments := struct {
		Argid types.ID `json:"id"`
	}{
		Argid: id,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] EnhancedDBAPI.Delete end")
	}()

	err := t.Internal.Delete(ctx, id)
	targetResults := struct {
		Error error
	}{
		Error: err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return err
}

// SetPassword is API call with trace log
func (t *EnhancedDBTracer) SetPassword(ctx context.Context, id types.ID, param *sacloud.EnhancedDBSetPasswordRequest) error {
	log.Println("[TRACE] EnhancedDBAPI.SetPassword start")
	targetArguments := struct {
		Argid    types.ID                              `json:"id"`
		Argparam *sacloud.EnhancedDBSetPasswordRequest `json:"param"`
	}{
		Argid:    id,
		Argparam: param,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] EnhancedDBAPI.SetPassword end")
	}()

	err := t.Internal.SetPassword(ctx, id, param)
	targetResults := struct {
		Error error
	}{
		Error: err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return err
}

/*************************************************
* ESMETracer
*************************************************/

// ESMETracer is for trace ESMEOp operations
type ESMETracer struct {
	Internal sacloud.ESMEAPI
}

// NewESMETracer creates new ESMETracer instance
func NewESMETracer(in sacloud.ESMEAPI) sacloud.ESMEAPI {
	return &ESMETracer{
		Internal: in,
	}
}

// Find is API call with trace log
func (t *ESMETracer) Find(ctx context.Context, conditions *sacloud.FindCondition) (*sacloud.ESMEFindResult, error) {
	log.Println("[TRACE] ESMEAPI.Find start")
	targetArguments := struct {
		Argconditions *sacloud.FindCondition `json:"conditions"`
	}{
		Argconditions: conditions,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] ESMEAPI.Find end")
	}()

	result, err := t.Internal.Find(ctx, conditions)
	targetResults := struct {
		Result *sacloud.ESMEFindResult
		Error  error
	}{
		Result: result,
		Error:  err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return result, err
}

// Create is API call with trace log
func (t *ESMETracer) Create(ctx context.Context, param *sacloud.ESMECreateRequest) (*sacloud.ESME, error) {
	log.Println("[TRACE] ESMEAPI.Create start")
	targetArguments := struct {
		Argparam *sacloud.ESMECreateRequest `json:"param"`
	}{
		Argparam: param,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] ESMEAPI.Create end")
	}()

	resultESME, err := t.Internal.Create(ctx, param)
	targetResults := struct {
		ESME  *sacloud.ESME
		Error error
	}{
		ESME:  resultESME,
		Error: err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultESME, err
}

// Read is API call with trace log
func (t *ESMETracer) Read(ctx context.Context, id types.ID) (*sacloud.ESME, error) {
	log.Println("[TRACE] ESMEAPI.Read start")
	targetArguments := struct {
		Argid types.ID `json:"id"`
	}{
		Argid: id,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] ESMEAPI.Read end")
	}()

	resultESME, err := t.Internal.Read(ctx, id)
	targetResults := struct {
		ESME  *sacloud.ESME
		Error error
	}{
		ESME:  resultESME,
		Error: err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultESME, err
}

// Update is API call with trace log
func (t *ESMETracer) Update(ctx context.Context, id types.ID, param *sacloud.ESMEUpdateRequest) (*sacloud.ESME, error) {
	log.Println("[TRACE] ESMEAPI.Update start")
	targetArguments := struct {
		Argid    types.ID                   `json:"id"`
		Argparam *sacloud.ESMEUpdateRequest `json:"param"`
	}{
		Argid:    id,
		Argparam: param,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] ESMEAPI.Update end")
	}()

	resultESME, err := t.Internal.Update(ctx, id, param)
	targetResults := struct {
		ESME  *sacloud.ESME
		Error error
	}{
		ESME:  resultESME,
		Error: err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultESME, err
}

// Delete is API call with trace log
func (t *ESMETracer) Delete(ctx context.Context, id types.ID) error {
	log.Println("[TRACE] ESMEAPI.Delete start")
	targetArguments := struct {
		Argid types.ID `json:"id"`
	}{
		Argid: id,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] ESMEAPI.Delete end")
	}()

	err := t.Internal.Delete(ctx, id)
	targetResults := struct {
		Error error
	}{
		Error: err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return err
}

// SendMessageWithGeneratedOTP is API call with trace log
func (t *ESMETracer) SendMessageWithGeneratedOTP(ctx context.Context, id types.ID, param *sacloud.ESMESendMessageWithGeneratedOTPRequest) (*sacloud.ESMESendMessageResult, error) {
	log.Println("[TRACE] ESMEAPI.SendMessageWithGeneratedOTP start")
	targetArguments := struct {
		Argid    types.ID                                        `json:"id"`
		Argparam *sacloud.ESMESendMessageWithGeneratedOTPRequest `json:"param"`
	}{
		Argid:    id,
		Argparam: param,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] ESMEAPI.SendMessageWithGeneratedOTP end")
	}()

	resultESMESendMessageResult, err := t.Internal.SendMessageWithGeneratedOTP(ctx, id, param)
	targetResults := struct {
		ESMESendMessageResult *sacloud.ESMESendMessageResult
		Error                 error
	}{
		ESMESendMessageResult: resultESMESendMessageResult,
		Error:                 err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultESMESendMessageResult, err
}

// SendMessageWithInputtedOTP is API call with trace log
func (t *ESMETracer) SendMessageWithInputtedOTP(ctx context.Context, id types.ID, param *sacloud.ESMESendMessageWithInputtedOTPRequest) (*sacloud.ESMESendMessageResult, error) {
	log.Println("[TRACE] ESMEAPI.SendMessageWithInputtedOTP start")
	targetArguments := struct {
		Argid    types.ID                                       `json:"id"`
		Argparam *sacloud.ESMESendMessageWithInputtedOTPRequest `json:"param"`
	}{
		Argid:    id,
		Argparam: param,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] ESMEAPI.SendMessageWithInputtedOTP end")
	}()

	resultESMESendMessageResult, err := t.Internal.SendMessageWithInputtedOTP(ctx, id, param)
	targetResults := struct {
		ESMESendMessageResult *sacloud.ESMESendMessageResult
		Error                 error
	}{
		ESMESendMessageResult: resultESMESendMessageResult,
		Error:                 err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultESMESendMessageResult, err
}

// Logs is API call with trace log
func (t *ESMETracer) Logs(ctx context.Context, id types.ID) ([]*sacloud.ESMELogs, error) {
	log.Println("[TRACE] ESMEAPI.Logs start")
	targetArguments := struct {
		Argid types.ID `json:"id"`
	}{
		Argid: id,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] ESMEAPI.Logs end")
	}()

	resultLogs, err := t.Internal.Logs(ctx, id)
	targetResults := struct {
		Logs  []*sacloud.ESMELogs
		Error error
	}{
		Logs:  resultLogs,
		Error: err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultLogs, err
}

/*************************************************
* GSLBTracer
*************************************************/

// GSLBTracer is for trace GSLBOp operations
type GSLBTracer struct {
	Internal sacloud.GSLBAPI
}

// NewGSLBTracer creates new GSLBTracer instance
func NewGSLBTracer(in sacloud.GSLBAPI) sacloud.GSLBAPI {
	return &GSLBTracer{
		Internal: in,
	}
}

// Find is API call with trace log
func (t *GSLBTracer) Find(ctx context.Context, conditions *sacloud.FindCondition) (*sacloud.GSLBFindResult, error) {
	log.Println("[TRACE] GSLBAPI.Find start")
	targetArguments := struct {
		Argconditions *sacloud.FindCondition `json:"conditions"`
	}{
		Argconditions: conditions,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] GSLBAPI.Find end")
	}()

	result, err := t.Internal.Find(ctx, conditions)
	targetResults := struct {
		Result *sacloud.GSLBFindResult
		Error  error
	}{
		Result: result,
		Error:  err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return result, err
}

// Create is API call with trace log
func (t *GSLBTracer) Create(ctx context.Context, param *sacloud.GSLBCreateRequest) (*sacloud.GSLB, error) {
	log.Println("[TRACE] GSLBAPI.Create start")
	targetArguments := struct {
		Argparam *sacloud.GSLBCreateRequest `json:"param"`
	}{
		Argparam: param,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] GSLBAPI.Create end")
	}()

	resultGSLB, err := t.Internal.Create(ctx, param)
	targetResults := struct {
		GSLB  *sacloud.GSLB
		Error error
	}{
		GSLB:  resultGSLB,
		Error: err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultGSLB, err
}

// Read is API call with trace log
func (t *GSLBTracer) Read(ctx context.Context, id types.ID) (*sacloud.GSLB, error) {
	log.Println("[TRACE] GSLBAPI.Read start")
	targetArguments := struct {
		Argid types.ID `json:"id"`
	}{
		Argid: id,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] GSLBAPI.Read end")
	}()

	resultGSLB, err := t.Internal.Read(ctx, id)
	targetResults := struct {
		GSLB  *sacloud.GSLB
		Error error
	}{
		GSLB:  resultGSLB,
		Error: err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultGSLB, err
}

// Update is API call with trace log
func (t *GSLBTracer) Update(ctx context.Context, id types.ID, param *sacloud.GSLBUpdateRequest) (*sacloud.GSLB, error) {
	log.Println("[TRACE] GSLBAPI.Update start")
	targetArguments := struct {
		Argid    types.ID                   `json:"id"`
		Argparam *sacloud.GSLBUpdateRequest `json:"param"`
	}{
		Argid:    id,
		Argparam: param,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] GSLBAPI.Update end")
	}()

	resultGSLB, err := t.Internal.Update(ctx, id, param)
	targetResults := struct {
		GSLB  *sacloud.GSLB
		Error error
	}{
		GSLB:  resultGSLB,
		Error: err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultGSLB, err
}

// UpdateSettings is API call with trace log
func (t *GSLBTracer) UpdateSettings(ctx context.Context, id types.ID, param *sacloud.GSLBUpdateSettingsRequest) (*sacloud.GSLB, error) {
	log.Println("[TRACE] GSLBAPI.UpdateSettings start")
	targetArguments := struct {
		Argid    types.ID                           `json:"id"`
		Argparam *sacloud.GSLBUpdateSettingsRequest `json:"param"`
	}{
		Argid:    id,
		Argparam: param,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] GSLBAPI.UpdateSettings end")
	}()

	resultGSLB, err := t.Internal.UpdateSettings(ctx, id, param)
	targetResults := struct {
		GSLB  *sacloud.GSLB
		Error error
	}{
		GSLB:  resultGSLB,
		Error: err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultGSLB, err
}

// Delete is API call with trace log
func (t *GSLBTracer) Delete(ctx context.Context, id types.ID) error {
	log.Println("[TRACE] GSLBAPI.Delete start")
	targetArguments := struct {
		Argid types.ID `json:"id"`
	}{
		Argid: id,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] GSLBAPI.Delete end")
	}()

	err := t.Internal.Delete(ctx, id)
	targetResults := struct {
		Error error
	}{
		Error: err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return err
}

/*************************************************
* IconTracer
*************************************************/

// IconTracer is for trace IconOp operations
type IconTracer struct {
	Internal sacloud.IconAPI
}

// NewIconTracer creates new IconTracer instance
func NewIconTracer(in sacloud.IconAPI) sacloud.IconAPI {
	return &IconTracer{
		Internal: in,
	}
}

// Find is API call with trace log
func (t *IconTracer) Find(ctx context.Context, conditions *sacloud.FindCondition) (*sacloud.IconFindResult, error) {
	log.Println("[TRACE] IconAPI.Find start")
	targetArguments := struct {
		Argconditions *sacloud.FindCondition `json:"conditions"`
	}{
		Argconditions: conditions,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] IconAPI.Find end")
	}()

	result, err := t.Internal.Find(ctx, conditions)
	targetResults := struct {
		Result *sacloud.IconFindResult
		Error  error
	}{
		Result: result,
		Error:  err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return result, err
}

// Create is API call with trace log
func (t *IconTracer) Create(ctx context.Context, param *sacloud.IconCreateRequest) (*sacloud.Icon, error) {
	log.Println("[TRACE] IconAPI.Create start")
	targetArguments := struct {
		Argparam *sacloud.IconCreateRequest `json:"param"`
	}{
		Argparam: param,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] IconAPI.Create end")
	}()

	resultIcon, err := t.Internal.Create(ctx, param)
	targetResults := struct {
		Icon  *sacloud.Icon
		Error error
	}{
		Icon:  resultIcon,
		Error: err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultIcon, err
}

// Read is API call with trace log
func (t *IconTracer) Read(ctx context.Context, id types.ID) (*sacloud.Icon, error) {
	log.Println("[TRACE] IconAPI.Read start")
	targetArguments := struct {
		Argid types.ID `json:"id"`
	}{
		Argid: id,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] IconAPI.Read end")
	}()

	resultIcon, err := t.Internal.Read(ctx, id)
	targetResults := struct {
		Icon  *sacloud.Icon
		Error error
	}{
		Icon:  resultIcon,
		Error: err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultIcon, err
}

// Update is API call with trace log
func (t *IconTracer) Update(ctx context.Context, id types.ID, param *sacloud.IconUpdateRequest) (*sacloud.Icon, error) {
	log.Println("[TRACE] IconAPI.Update start")
	targetArguments := struct {
		Argid    types.ID                   `json:"id"`
		Argparam *sacloud.IconUpdateRequest `json:"param"`
	}{
		Argid:    id,
		Argparam: param,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] IconAPI.Update end")
	}()

	resultIcon, err := t.Internal.Update(ctx, id, param)
	targetResults := struct {
		Icon  *sacloud.Icon
		Error error
	}{
		Icon:  resultIcon,
		Error: err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultIcon, err
}

// Delete is API call with trace log
func (t *IconTracer) Delete(ctx context.Context, id types.ID) error {
	log.Println("[TRACE] IconAPI.Delete start")
	targetArguments := struct {
		Argid types.ID `json:"id"`
	}{
		Argid: id,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] IconAPI.Delete end")
	}()

	err := t.Internal.Delete(ctx, id)
	targetResults := struct {
		Error error
	}{
		Error: err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return err
}

/*************************************************
* InterfaceTracer
*************************************************/

// InterfaceTracer is for trace InterfaceOp operations
type InterfaceTracer struct {
	Internal sacloud.InterfaceAPI
}

// NewInterfaceTracer creates new InterfaceTracer instance
func NewInterfaceTracer(in sacloud.InterfaceAPI) sacloud.InterfaceAPI {
	return &InterfaceTracer{
		Internal: in,
	}
}

// Find is API call with trace log
func (t *InterfaceTracer) Find(ctx context.Context, zone string, conditions *sacloud.FindCondition) (*sacloud.InterfaceFindResult, error) {
	log.Println("[TRACE] InterfaceAPI.Find start")
	targetArguments := struct {
		Argzone       string
		Argconditions *sacloud.FindCondition `json:"conditions"`
	}{
		Argzone:       zone,
		Argconditions: conditions,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] InterfaceAPI.Find end")
	}()

	result, err := t.Internal.Find(ctx, zone, conditions)
	targetResults := struct {
		Result *sacloud.InterfaceFindResult
		Error  error
	}{
		Result: result,
		Error:  err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return result, err
}

// Create is API call with trace log
func (t *InterfaceTracer) Create(ctx context.Context, zone string, param *sacloud.InterfaceCreateRequest) (*sacloud.Interface, error) {
	log.Println("[TRACE] InterfaceAPI.Create start")
	targetArguments := struct {
		Argzone  string
		Argparam *sacloud.InterfaceCreateRequest `json:"param"`
	}{
		Argzone:  zone,
		Argparam: param,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] InterfaceAPI.Create end")
	}()

	resultInterface, err := t.Internal.Create(ctx, zone, param)
	targetResults := struct {
		Interface *sacloud.Interface
		Error     error
	}{
		Interface: resultInterface,
		Error:     err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultInterface, err
}

// Read is API call with trace log
func (t *InterfaceTracer) Read(ctx context.Context, zone string, id types.ID) (*sacloud.Interface, error) {
	log.Println("[TRACE] InterfaceAPI.Read start")
	targetArguments := struct {
		Argzone string
		Argid   types.ID `json:"id"`
	}{
		Argzone: zone,
		Argid:   id,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] InterfaceAPI.Read end")
	}()

	resultInterface, err := t.Internal.Read(ctx, zone, id)
	targetResults := struct {
		Interface *sacloud.Interface
		Error     error
	}{
		Interface: resultInterface,
		Error:     err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultInterface, err
}

// Update is API call with trace log
func (t *InterfaceTracer) Update(ctx context.Context, zone string, id types.ID, param *sacloud.InterfaceUpdateRequest) (*sacloud.Interface, error) {
	log.Println("[TRACE] InterfaceAPI.Update start")
	targetArguments := struct {
		Argzone  string
		Argid    types.ID                        `json:"id"`
		Argparam *sacloud.InterfaceUpdateRequest `json:"param"`
	}{
		Argzone:  zone,
		Argid:    id,
		Argparam: param,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] InterfaceAPI.Update end")
	}()

	resultInterface, err := t.Internal.Update(ctx, zone, id, param)
	targetResults := struct {
		Interface *sacloud.Interface
		Error     error
	}{
		Interface: resultInterface,
		Error:     err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultInterface, err
}

// Delete is API call with trace log
func (t *InterfaceTracer) Delete(ctx context.Context, zone string, id types.ID) error {
	log.Println("[TRACE] InterfaceAPI.Delete start")
	targetArguments := struct {
		Argzone string
		Argid   types.ID `json:"id"`
	}{
		Argzone: zone,
		Argid:   id,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] InterfaceAPI.Delete end")
	}()

	err := t.Internal.Delete(ctx, zone, id)
	targetResults := struct {
		Error error
	}{
		Error: err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return err
}

// Monitor is API call with trace log
func (t *InterfaceTracer) Monitor(ctx context.Context, zone string, id types.ID, condition *sacloud.MonitorCondition) (*sacloud.InterfaceActivity, error) {
	log.Println("[TRACE] InterfaceAPI.Monitor start")
	targetArguments := struct {
		Argzone      string
		Argid        types.ID                  `json:"id"`
		Argcondition *sacloud.MonitorCondition `json:"condition"`
	}{
		Argzone:      zone,
		Argid:        id,
		Argcondition: condition,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] InterfaceAPI.Monitor end")
	}()

	resultInterfaceActivity, err := t.Internal.Monitor(ctx, zone, id, condition)
	targetResults := struct {
		InterfaceActivity *sacloud.InterfaceActivity
		Error             error
	}{
		InterfaceActivity: resultInterfaceActivity,
		Error:             err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultInterfaceActivity, err
}

// ConnectToSharedSegment is API call with trace log
func (t *InterfaceTracer) ConnectToSharedSegment(ctx context.Context, zone string, id types.ID) error {
	log.Println("[TRACE] InterfaceAPI.ConnectToSharedSegment start")
	targetArguments := struct {
		Argzone string
		Argid   types.ID `json:"id"`
	}{
		Argzone: zone,
		Argid:   id,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] InterfaceAPI.ConnectToSharedSegment end")
	}()

	err := t.Internal.ConnectToSharedSegment(ctx, zone, id)
	targetResults := struct {
		Error error
	}{
		Error: err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return err
}

// ConnectToSwitch is API call with trace log
func (t *InterfaceTracer) ConnectToSwitch(ctx context.Context, zone string, id types.ID, switchID types.ID) error {
	log.Println("[TRACE] InterfaceAPI.ConnectToSwitch start")
	targetArguments := struct {
		Argzone     string
		Argid       types.ID `json:"id"`
		ArgswitchID types.ID `json:"switchID"`
	}{
		Argzone:     zone,
		Argid:       id,
		ArgswitchID: switchID,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] InterfaceAPI.ConnectToSwitch end")
	}()

	err := t.Internal.ConnectToSwitch(ctx, zone, id, switchID)
	targetResults := struct {
		Error error
	}{
		Error: err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return err
}

// DisconnectFromSwitch is API call with trace log
func (t *InterfaceTracer) DisconnectFromSwitch(ctx context.Context, zone string, id types.ID) error {
	log.Println("[TRACE] InterfaceAPI.DisconnectFromSwitch start")
	targetArguments := struct {
		Argzone string
		Argid   types.ID `json:"id"`
	}{
		Argzone: zone,
		Argid:   id,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] InterfaceAPI.DisconnectFromSwitch end")
	}()

	err := t.Internal.DisconnectFromSwitch(ctx, zone, id)
	targetResults := struct {
		Error error
	}{
		Error: err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return err
}

// ConnectToPacketFilter is API call with trace log
func (t *InterfaceTracer) ConnectToPacketFilter(ctx context.Context, zone string, id types.ID, packetFilterID types.ID) error {
	log.Println("[TRACE] InterfaceAPI.ConnectToPacketFilter start")
	targetArguments := struct {
		Argzone           string
		Argid             types.ID `json:"id"`
		ArgpacketFilterID types.ID `json:"packetFilterID"`
	}{
		Argzone:           zone,
		Argid:             id,
		ArgpacketFilterID: packetFilterID,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] InterfaceAPI.ConnectToPacketFilter end")
	}()

	err := t.Internal.ConnectToPacketFilter(ctx, zone, id, packetFilterID)
	targetResults := struct {
		Error error
	}{
		Error: err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return err
}

// DisconnectFromPacketFilter is API call with trace log
func (t *InterfaceTracer) DisconnectFromPacketFilter(ctx context.Context, zone string, id types.ID) error {
	log.Println("[TRACE] InterfaceAPI.DisconnectFromPacketFilter start")
	targetArguments := struct {
		Argzone string
		Argid   types.ID `json:"id"`
	}{
		Argzone: zone,
		Argid:   id,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] InterfaceAPI.DisconnectFromPacketFilter end")
	}()

	err := t.Internal.DisconnectFromPacketFilter(ctx, zone, id)
	targetResults := struct {
		Error error
	}{
		Error: err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return err
}

/*************************************************
* InternetTracer
*************************************************/

// InternetTracer is for trace InternetOp operations
type InternetTracer struct {
	Internal sacloud.InternetAPI
}

// NewInternetTracer creates new InternetTracer instance
func NewInternetTracer(in sacloud.InternetAPI) sacloud.InternetAPI {
	return &InternetTracer{
		Internal: in,
	}
}

// Find is API call with trace log
func (t *InternetTracer) Find(ctx context.Context, zone string, conditions *sacloud.FindCondition) (*sacloud.InternetFindResult, error) {
	log.Println("[TRACE] InternetAPI.Find start")
	targetArguments := struct {
		Argzone       string
		Argconditions *sacloud.FindCondition `json:"conditions"`
	}{
		Argzone:       zone,
		Argconditions: conditions,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] InternetAPI.Find end")
	}()

	result, err := t.Internal.Find(ctx, zone, conditions)
	targetResults := struct {
		Result *sacloud.InternetFindResult
		Error  error
	}{
		Result: result,
		Error:  err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return result, err
}

// Create is API call with trace log
func (t *InternetTracer) Create(ctx context.Context, zone string, param *sacloud.InternetCreateRequest) (*sacloud.Internet, error) {
	log.Println("[TRACE] InternetAPI.Create start")
	targetArguments := struct {
		Argzone  string
		Argparam *sacloud.InternetCreateRequest `json:"param"`
	}{
		Argzone:  zone,
		Argparam: param,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] InternetAPI.Create end")
	}()

	resultInternet, err := t.Internal.Create(ctx, zone, param)
	targetResults := struct {
		Internet *sacloud.Internet
		Error    error
	}{
		Internet: resultInternet,
		Error:    err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultInternet, err
}

// Read is API call with trace log
func (t *InternetTracer) Read(ctx context.Context, zone string, id types.ID) (*sacloud.Internet, error) {
	log.Println("[TRACE] InternetAPI.Read start")
	targetArguments := struct {
		Argzone string
		Argid   types.ID `json:"id"`
	}{
		Argzone: zone,
		Argid:   id,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] InternetAPI.Read end")
	}()

	resultInternet, err := t.Internal.Read(ctx, zone, id)
	targetResults := struct {
		Internet *sacloud.Internet
		Error    error
	}{
		Internet: resultInternet,
		Error:    err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultInternet, err
}

// Update is API call with trace log
func (t *InternetTracer) Update(ctx context.Context, zone string, id types.ID, param *sacloud.InternetUpdateRequest) (*sacloud.Internet, error) {
	log.Println("[TRACE] InternetAPI.Update start")
	targetArguments := struct {
		Argzone  string
		Argid    types.ID                       `json:"id"`
		Argparam *sacloud.InternetUpdateRequest `json:"param"`
	}{
		Argzone:  zone,
		Argid:    id,
		Argparam: param,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] InternetAPI.Update end")
	}()

	resultInternet, err := t.Internal.Update(ctx, zone, id, param)
	targetResults := struct {
		Internet *sacloud.Internet
		Error    error
	}{
		Internet: resultInternet,
		Error:    err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultInternet, err
}

// Delete is API call with trace log
func (t *InternetTracer) Delete(ctx context.Context, zone string, id types.ID) error {
	log.Println("[TRACE] InternetAPI.Delete start")
	targetArguments := struct {
		Argzone string
		Argid   types.ID `json:"id"`
	}{
		Argzone: zone,
		Argid:   id,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] InternetAPI.Delete end")
	}()

	err := t.Internal.Delete(ctx, zone, id)
	targetResults := struct {
		Error error
	}{
		Error: err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return err
}

// UpdateBandWidth is API call with trace log
func (t *InternetTracer) UpdateBandWidth(ctx context.Context, zone string, id types.ID, param *sacloud.InternetUpdateBandWidthRequest) (*sacloud.Internet, error) {
	log.Println("[TRACE] InternetAPI.UpdateBandWidth start")
	targetArguments := struct {
		Argzone  string
		Argid    types.ID                                `json:"id"`
		Argparam *sacloud.InternetUpdateBandWidthRequest `json:"param"`
	}{
		Argzone:  zone,
		Argid:    id,
		Argparam: param,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] InternetAPI.UpdateBandWidth end")
	}()

	resultInternet, err := t.Internal.UpdateBandWidth(ctx, zone, id, param)
	targetResults := struct {
		Internet *sacloud.Internet
		Error    error
	}{
		Internet: resultInternet,
		Error:    err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultInternet, err
}

// AddSubnet is API call with trace log
func (t *InternetTracer) AddSubnet(ctx context.Context, zone string, id types.ID, param *sacloud.InternetAddSubnetRequest) (*sacloud.InternetSubnetOperationResult, error) {
	log.Println("[TRACE] InternetAPI.AddSubnet start")
	targetArguments := struct {
		Argzone  string
		Argid    types.ID                          `json:"id"`
		Argparam *sacloud.InternetAddSubnetRequest `json:"param"`
	}{
		Argzone:  zone,
		Argid:    id,
		Argparam: param,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] InternetAPI.AddSubnet end")
	}()

	resultSubnet, err := t.Internal.AddSubnet(ctx, zone, id, param)
	targetResults := struct {
		Subnet *sacloud.InternetSubnetOperationResult
		Error  error
	}{
		Subnet: resultSubnet,
		Error:  err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultSubnet, err
}

// UpdateSubnet is API call with trace log
func (t *InternetTracer) UpdateSubnet(ctx context.Context, zone string, id types.ID, subnetID types.ID, param *sacloud.InternetUpdateSubnetRequest) (*sacloud.InternetSubnetOperationResult, error) {
	log.Println("[TRACE] InternetAPI.UpdateSubnet start")
	targetArguments := struct {
		Argzone     string
		Argid       types.ID                             `json:"id"`
		ArgsubnetID types.ID                             `json:"subnetID"`
		Argparam    *sacloud.InternetUpdateSubnetRequest `json:"param"`
	}{
		Argzone:     zone,
		Argid:       id,
		ArgsubnetID: subnetID,
		Argparam:    param,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] InternetAPI.UpdateSubnet end")
	}()

	resultSubnet, err := t.Internal.UpdateSubnet(ctx, zone, id, subnetID, param)
	targetResults := struct {
		Subnet *sacloud.InternetSubnetOperationResult
		Error  error
	}{
		Subnet: resultSubnet,
		Error:  err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultSubnet, err
}

// DeleteSubnet is API call with trace log
func (t *InternetTracer) DeleteSubnet(ctx context.Context, zone string, id types.ID, subnetID types.ID) error {
	log.Println("[TRACE] InternetAPI.DeleteSubnet start")
	targetArguments := struct {
		Argzone     string
		Argid       types.ID `json:"id"`
		ArgsubnetID types.ID `json:"subnetID"`
	}{
		Argzone:     zone,
		Argid:       id,
		ArgsubnetID: subnetID,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] InternetAPI.DeleteSubnet end")
	}()

	err := t.Internal.DeleteSubnet(ctx, zone, id, subnetID)
	targetResults := struct {
		Error error
	}{
		Error: err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return err
}

// Monitor is API call with trace log
func (t *InternetTracer) Monitor(ctx context.Context, zone string, id types.ID, condition *sacloud.MonitorCondition) (*sacloud.RouterActivity, error) {
	log.Println("[TRACE] InternetAPI.Monitor start")
	targetArguments := struct {
		Argzone      string
		Argid        types.ID                  `json:"id"`
		Argcondition *sacloud.MonitorCondition `json:"condition"`
	}{
		Argzone:      zone,
		Argid:        id,
		Argcondition: condition,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] InternetAPI.Monitor end")
	}()

	resultRouterActivity, err := t.Internal.Monitor(ctx, zone, id, condition)
	targetResults := struct {
		RouterActivity *sacloud.RouterActivity
		Error          error
	}{
		RouterActivity: resultRouterActivity,
		Error:          err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultRouterActivity, err
}

// MonitorRouter is API call with trace log
func (t *InternetTracer) MonitorRouter(ctx context.Context, zone string, id types.ID, condition *sacloud.MonitorCondition) (*sacloud.RouterActivity, error) {
	log.Println("[TRACE] InternetAPI.MonitorRouter start")
	targetArguments := struct {
		Argzone      string
		Argid        types.ID                  `json:"id"`
		Argcondition *sacloud.MonitorCondition `json:"condition"`
	}{
		Argzone:      zone,
		Argid:        id,
		Argcondition: condition,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] InternetAPI.MonitorRouter end")
	}()

	resultRouterActivity, err := t.Internal.MonitorRouter(ctx, zone, id, condition)
	targetResults := struct {
		RouterActivity *sacloud.RouterActivity
		Error          error
	}{
		RouterActivity: resultRouterActivity,
		Error:          err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultRouterActivity, err
}

// EnableIPv6 is API call with trace log
func (t *InternetTracer) EnableIPv6(ctx context.Context, zone string, id types.ID) (*sacloud.IPv6NetInfo, error) {
	log.Println("[TRACE] InternetAPI.EnableIPv6 start")
	targetArguments := struct {
		Argzone string
		Argid   types.ID `json:"id"`
	}{
		Argzone: zone,
		Argid:   id,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] InternetAPI.EnableIPv6 end")
	}()

	resultIPv6Net, err := t.Internal.EnableIPv6(ctx, zone, id)
	targetResults := struct {
		IPv6Net *sacloud.IPv6NetInfo
		Error   error
	}{
		IPv6Net: resultIPv6Net,
		Error:   err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultIPv6Net, err
}

// DisableIPv6 is API call with trace log
func (t *InternetTracer) DisableIPv6(ctx context.Context, zone string, id types.ID, ipv6netID types.ID) error {
	log.Println("[TRACE] InternetAPI.DisableIPv6 start")
	targetArguments := struct {
		Argzone      string
		Argid        types.ID `json:"id"`
		Argipv6netID types.ID `json:"ipv6netID"`
	}{
		Argzone:      zone,
		Argid:        id,
		Argipv6netID: ipv6netID,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] InternetAPI.DisableIPv6 end")
	}()

	err := t.Internal.DisableIPv6(ctx, zone, id, ipv6netID)
	targetResults := struct {
		Error error
	}{
		Error: err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return err
}

/*************************************************
* InternetPlanTracer
*************************************************/

// InternetPlanTracer is for trace InternetPlanOp operations
type InternetPlanTracer struct {
	Internal sacloud.InternetPlanAPI
}

// NewInternetPlanTracer creates new InternetPlanTracer instance
func NewInternetPlanTracer(in sacloud.InternetPlanAPI) sacloud.InternetPlanAPI {
	return &InternetPlanTracer{
		Internal: in,
	}
}

// Find is API call with trace log
func (t *InternetPlanTracer) Find(ctx context.Context, zone string, conditions *sacloud.FindCondition) (*sacloud.InternetPlanFindResult, error) {
	log.Println("[TRACE] InternetPlanAPI.Find start")
	targetArguments := struct {
		Argzone       string
		Argconditions *sacloud.FindCondition `json:"conditions"`
	}{
		Argzone:       zone,
		Argconditions: conditions,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] InternetPlanAPI.Find end")
	}()

	result, err := t.Internal.Find(ctx, zone, conditions)
	targetResults := struct {
		Result *sacloud.InternetPlanFindResult
		Error  error
	}{
		Result: result,
		Error:  err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return result, err
}

// Read is API call with trace log
func (t *InternetPlanTracer) Read(ctx context.Context, zone string, id types.ID) (*sacloud.InternetPlan, error) {
	log.Println("[TRACE] InternetPlanAPI.Read start")
	targetArguments := struct {
		Argzone string
		Argid   types.ID `json:"id"`
	}{
		Argzone: zone,
		Argid:   id,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] InternetPlanAPI.Read end")
	}()

	resultInternetPlan, err := t.Internal.Read(ctx, zone, id)
	targetResults := struct {
		InternetPlan *sacloud.InternetPlan
		Error        error
	}{
		InternetPlan: resultInternetPlan,
		Error:        err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultInternetPlan, err
}

/*************************************************
* IPAddressTracer
*************************************************/

// IPAddressTracer is for trace IPAddressOp operations
type IPAddressTracer struct {
	Internal sacloud.IPAddressAPI
}

// NewIPAddressTracer creates new IPAddressTracer instance
func NewIPAddressTracer(in sacloud.IPAddressAPI) sacloud.IPAddressAPI {
	return &IPAddressTracer{
		Internal: in,
	}
}

// List is API call with trace log
func (t *IPAddressTracer) List(ctx context.Context, zone string) (*sacloud.IPAddressListResult, error) {
	log.Println("[TRACE] IPAddressAPI.List start")
	targetArguments := struct {
		Argzone string
	}{
		Argzone: zone,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] IPAddressAPI.List end")
	}()

	result, err := t.Internal.List(ctx, zone)
	targetResults := struct {
		Result *sacloud.IPAddressListResult
		Error  error
	}{
		Result: result,
		Error:  err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return result, err
}

// Read is API call with trace log
func (t *IPAddressTracer) Read(ctx context.Context, zone string, ipAddress string) (*sacloud.IPAddress, error) {
	log.Println("[TRACE] IPAddressAPI.Read start")
	targetArguments := struct {
		Argzone      string
		ArgipAddress string `json:"ipAddress"`
	}{
		Argzone:      zone,
		ArgipAddress: ipAddress,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] IPAddressAPI.Read end")
	}()

	resultIPAddress, err := t.Internal.Read(ctx, zone, ipAddress)
	targetResults := struct {
		IPAddress *sacloud.IPAddress
		Error     error
	}{
		IPAddress: resultIPAddress,
		Error:     err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultIPAddress, err
}

// UpdateHostName is API call with trace log
func (t *IPAddressTracer) UpdateHostName(ctx context.Context, zone string, ipAddress string, hostName string) (*sacloud.IPAddress, error) {
	log.Println("[TRACE] IPAddressAPI.UpdateHostName start")
	targetArguments := struct {
		Argzone      string
		ArgipAddress string `json:"ipAddress"`
		ArghostName  string `json:"hostName"`
	}{
		Argzone:      zone,
		ArgipAddress: ipAddress,
		ArghostName:  hostName,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] IPAddressAPI.UpdateHostName end")
	}()

	resultIPAddress, err := t.Internal.UpdateHostName(ctx, zone, ipAddress, hostName)
	targetResults := struct {
		IPAddress *sacloud.IPAddress
		Error     error
	}{
		IPAddress: resultIPAddress,
		Error:     err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultIPAddress, err
}

/*************************************************
* IPv6NetTracer
*************************************************/

// IPv6NetTracer is for trace IPv6NetOp operations
type IPv6NetTracer struct {
	Internal sacloud.IPv6NetAPI
}

// NewIPv6NetTracer creates new IPv6NetTracer instance
func NewIPv6NetTracer(in sacloud.IPv6NetAPI) sacloud.IPv6NetAPI {
	return &IPv6NetTracer{
		Internal: in,
	}
}

// List is API call with trace log
func (t *IPv6NetTracer) List(ctx context.Context, zone string) (*sacloud.IPv6NetListResult, error) {
	log.Println("[TRACE] IPv6NetAPI.List start")
	targetArguments := struct {
		Argzone string
	}{
		Argzone: zone,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] IPv6NetAPI.List end")
	}()

	result, err := t.Internal.List(ctx, zone)
	targetResults := struct {
		Result *sacloud.IPv6NetListResult
		Error  error
	}{
		Result: result,
		Error:  err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return result, err
}

// Find is API call with trace log
func (t *IPv6NetTracer) Find(ctx context.Context, zone string, conditions *sacloud.FindCondition) (*sacloud.IPv6NetFindResult, error) {
	log.Println("[TRACE] IPv6NetAPI.Find start")
	targetArguments := struct {
		Argzone       string
		Argconditions *sacloud.FindCondition `json:"conditions"`
	}{
		Argzone:       zone,
		Argconditions: conditions,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] IPv6NetAPI.Find end")
	}()

	result, err := t.Internal.Find(ctx, zone, conditions)
	targetResults := struct {
		Result *sacloud.IPv6NetFindResult
		Error  error
	}{
		Result: result,
		Error:  err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return result, err
}

// Read is API call with trace log
func (t *IPv6NetTracer) Read(ctx context.Context, zone string, id types.ID) (*sacloud.IPv6Net, error) {
	log.Println("[TRACE] IPv6NetAPI.Read start")
	targetArguments := struct {
		Argzone string
		Argid   types.ID `json:"id"`
	}{
		Argzone: zone,
		Argid:   id,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] IPv6NetAPI.Read end")
	}()

	resultIPv6Net, err := t.Internal.Read(ctx, zone, id)
	targetResults := struct {
		IPv6Net *sacloud.IPv6Net
		Error   error
	}{
		IPv6Net: resultIPv6Net,
		Error:   err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultIPv6Net, err
}

/*************************************************
* IPv6AddrTracer
*************************************************/

// IPv6AddrTracer is for trace IPv6AddrOp operations
type IPv6AddrTracer struct {
	Internal sacloud.IPv6AddrAPI
}

// NewIPv6AddrTracer creates new IPv6AddrTracer instance
func NewIPv6AddrTracer(in sacloud.IPv6AddrAPI) sacloud.IPv6AddrAPI {
	return &IPv6AddrTracer{
		Internal: in,
	}
}

// Find is API call with trace log
func (t *IPv6AddrTracer) Find(ctx context.Context, zone string, conditions *sacloud.FindCondition) (*sacloud.IPv6AddrFindResult, error) {
	log.Println("[TRACE] IPv6AddrAPI.Find start")
	targetArguments := struct {
		Argzone       string
		Argconditions *sacloud.FindCondition `json:"conditions"`
	}{
		Argzone:       zone,
		Argconditions: conditions,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] IPv6AddrAPI.Find end")
	}()

	result, err := t.Internal.Find(ctx, zone, conditions)
	targetResults := struct {
		Result *sacloud.IPv6AddrFindResult
		Error  error
	}{
		Result: result,
		Error:  err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return result, err
}

// Create is API call with trace log
func (t *IPv6AddrTracer) Create(ctx context.Context, zone string, param *sacloud.IPv6AddrCreateRequest) (*sacloud.IPv6Addr, error) {
	log.Println("[TRACE] IPv6AddrAPI.Create start")
	targetArguments := struct {
		Argzone  string
		Argparam *sacloud.IPv6AddrCreateRequest `json:"param"`
	}{
		Argzone:  zone,
		Argparam: param,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] IPv6AddrAPI.Create end")
	}()

	resultIPv6Addr, err := t.Internal.Create(ctx, zone, param)
	targetResults := struct {
		IPv6Addr *sacloud.IPv6Addr
		Error    error
	}{
		IPv6Addr: resultIPv6Addr,
		Error:    err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultIPv6Addr, err
}

// Read is API call with trace log
func (t *IPv6AddrTracer) Read(ctx context.Context, zone string, ipv6addr string) (*sacloud.IPv6Addr, error) {
	log.Println("[TRACE] IPv6AddrAPI.Read start")
	targetArguments := struct {
		Argzone     string
		Argipv6addr string `json:"ipv6addr"`
	}{
		Argzone:     zone,
		Argipv6addr: ipv6addr,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] IPv6AddrAPI.Read end")
	}()

	resultIPv6Addr, err := t.Internal.Read(ctx, zone, ipv6addr)
	targetResults := struct {
		IPv6Addr *sacloud.IPv6Addr
		Error    error
	}{
		IPv6Addr: resultIPv6Addr,
		Error:    err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultIPv6Addr, err
}

// Update is API call with trace log
func (t *IPv6AddrTracer) Update(ctx context.Context, zone string, ipv6addr string, param *sacloud.IPv6AddrUpdateRequest) (*sacloud.IPv6Addr, error) {
	log.Println("[TRACE] IPv6AddrAPI.Update start")
	targetArguments := struct {
		Argzone     string
		Argipv6addr string                         `json:"ipv6addr"`
		Argparam    *sacloud.IPv6AddrUpdateRequest `json:"param"`
	}{
		Argzone:     zone,
		Argipv6addr: ipv6addr,
		Argparam:    param,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] IPv6AddrAPI.Update end")
	}()

	resultIPv6Addr, err := t.Internal.Update(ctx, zone, ipv6addr, param)
	targetResults := struct {
		IPv6Addr *sacloud.IPv6Addr
		Error    error
	}{
		IPv6Addr: resultIPv6Addr,
		Error:    err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultIPv6Addr, err
}

// Delete is API call with trace log
func (t *IPv6AddrTracer) Delete(ctx context.Context, zone string, ipv6addr string) error {
	log.Println("[TRACE] IPv6AddrAPI.Delete start")
	targetArguments := struct {
		Argzone     string
		Argipv6addr string `json:"ipv6addr"`
	}{
		Argzone:     zone,
		Argipv6addr: ipv6addr,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] IPv6AddrAPI.Delete end")
	}()

	err := t.Internal.Delete(ctx, zone, ipv6addr)
	targetResults := struct {
		Error error
	}{
		Error: err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return err
}

/*************************************************
* LicenseTracer
*************************************************/

// LicenseTracer is for trace LicenseOp operations
type LicenseTracer struct {
	Internal sacloud.LicenseAPI
}

// NewLicenseTracer creates new LicenseTracer instance
func NewLicenseTracer(in sacloud.LicenseAPI) sacloud.LicenseAPI {
	return &LicenseTracer{
		Internal: in,
	}
}

// Find is API call with trace log
func (t *LicenseTracer) Find(ctx context.Context, conditions *sacloud.FindCondition) (*sacloud.LicenseFindResult, error) {
	log.Println("[TRACE] LicenseAPI.Find start")
	targetArguments := struct {
		Argconditions *sacloud.FindCondition `json:"conditions"`
	}{
		Argconditions: conditions,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] LicenseAPI.Find end")
	}()

	result, err := t.Internal.Find(ctx, conditions)
	targetResults := struct {
		Result *sacloud.LicenseFindResult
		Error  error
	}{
		Result: result,
		Error:  err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return result, err
}

// Create is API call with trace log
func (t *LicenseTracer) Create(ctx context.Context, param *sacloud.LicenseCreateRequest) (*sacloud.License, error) {
	log.Println("[TRACE] LicenseAPI.Create start")
	targetArguments := struct {
		Argparam *sacloud.LicenseCreateRequest `json:"param"`
	}{
		Argparam: param,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] LicenseAPI.Create end")
	}()

	resultLicense, err := t.Internal.Create(ctx, param)
	targetResults := struct {
		License *sacloud.License
		Error   error
	}{
		License: resultLicense,
		Error:   err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultLicense, err
}

// Read is API call with trace log
func (t *LicenseTracer) Read(ctx context.Context, id types.ID) (*sacloud.License, error) {
	log.Println("[TRACE] LicenseAPI.Read start")
	targetArguments := struct {
		Argid types.ID `json:"id"`
	}{
		Argid: id,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] LicenseAPI.Read end")
	}()

	resultLicense, err := t.Internal.Read(ctx, id)
	targetResults := struct {
		License *sacloud.License
		Error   error
	}{
		License: resultLicense,
		Error:   err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultLicense, err
}

// Update is API call with trace log
func (t *LicenseTracer) Update(ctx context.Context, id types.ID, param *sacloud.LicenseUpdateRequest) (*sacloud.License, error) {
	log.Println("[TRACE] LicenseAPI.Update start")
	targetArguments := struct {
		Argid    types.ID                      `json:"id"`
		Argparam *sacloud.LicenseUpdateRequest `json:"param"`
	}{
		Argid:    id,
		Argparam: param,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] LicenseAPI.Update end")
	}()

	resultLicense, err := t.Internal.Update(ctx, id, param)
	targetResults := struct {
		License *sacloud.License
		Error   error
	}{
		License: resultLicense,
		Error:   err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultLicense, err
}

// Delete is API call with trace log
func (t *LicenseTracer) Delete(ctx context.Context, id types.ID) error {
	log.Println("[TRACE] LicenseAPI.Delete start")
	targetArguments := struct {
		Argid types.ID `json:"id"`
	}{
		Argid: id,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] LicenseAPI.Delete end")
	}()

	err := t.Internal.Delete(ctx, id)
	targetResults := struct {
		Error error
	}{
		Error: err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return err
}

/*************************************************
* LicenseInfoTracer
*************************************************/

// LicenseInfoTracer is for trace LicenseInfoOp operations
type LicenseInfoTracer struct {
	Internal sacloud.LicenseInfoAPI
}

// NewLicenseInfoTracer creates new LicenseInfoTracer instance
func NewLicenseInfoTracer(in sacloud.LicenseInfoAPI) sacloud.LicenseInfoAPI {
	return &LicenseInfoTracer{
		Internal: in,
	}
}

// Find is API call with trace log
func (t *LicenseInfoTracer) Find(ctx context.Context, conditions *sacloud.FindCondition) (*sacloud.LicenseInfoFindResult, error) {
	log.Println("[TRACE] LicenseInfoAPI.Find start")
	targetArguments := struct {
		Argconditions *sacloud.FindCondition `json:"conditions"`
	}{
		Argconditions: conditions,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] LicenseInfoAPI.Find end")
	}()

	result, err := t.Internal.Find(ctx, conditions)
	targetResults := struct {
		Result *sacloud.LicenseInfoFindResult
		Error  error
	}{
		Result: result,
		Error:  err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return result, err
}

// Read is API call with trace log
func (t *LicenseInfoTracer) Read(ctx context.Context, id types.ID) (*sacloud.LicenseInfo, error) {
	log.Println("[TRACE] LicenseInfoAPI.Read start")
	targetArguments := struct {
		Argid types.ID `json:"id"`
	}{
		Argid: id,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] LicenseInfoAPI.Read end")
	}()

	resultLicenseInfo, err := t.Internal.Read(ctx, id)
	targetResults := struct {
		LicenseInfo *sacloud.LicenseInfo
		Error       error
	}{
		LicenseInfo: resultLicenseInfo,
		Error:       err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultLicenseInfo, err
}

/*************************************************
* LoadBalancerTracer
*************************************************/

// LoadBalancerTracer is for trace LoadBalancerOp operations
type LoadBalancerTracer struct {
	Internal sacloud.LoadBalancerAPI
}

// NewLoadBalancerTracer creates new LoadBalancerTracer instance
func NewLoadBalancerTracer(in sacloud.LoadBalancerAPI) sacloud.LoadBalancerAPI {
	return &LoadBalancerTracer{
		Internal: in,
	}
}

// Find is API call with trace log
func (t *LoadBalancerTracer) Find(ctx context.Context, zone string, conditions *sacloud.FindCondition) (*sacloud.LoadBalancerFindResult, error) {
	log.Println("[TRACE] LoadBalancerAPI.Find start")
	targetArguments := struct {
		Argzone       string
		Argconditions *sacloud.FindCondition `json:"conditions"`
	}{
		Argzone:       zone,
		Argconditions: conditions,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] LoadBalancerAPI.Find end")
	}()

	result, err := t.Internal.Find(ctx, zone, conditions)
	targetResults := struct {
		Result *sacloud.LoadBalancerFindResult
		Error  error
	}{
		Result: result,
		Error:  err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return result, err
}

// Create is API call with trace log
func (t *LoadBalancerTracer) Create(ctx context.Context, zone string, param *sacloud.LoadBalancerCreateRequest) (*sacloud.LoadBalancer, error) {
	log.Println("[TRACE] LoadBalancerAPI.Create start")
	targetArguments := struct {
		Argzone  string
		Argparam *sacloud.LoadBalancerCreateRequest `json:"param"`
	}{
		Argzone:  zone,
		Argparam: param,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] LoadBalancerAPI.Create end")
	}()

	resultLoadBalancer, err := t.Internal.Create(ctx, zone, param)
	targetResults := struct {
		LoadBalancer *sacloud.LoadBalancer
		Error        error
	}{
		LoadBalancer: resultLoadBalancer,
		Error:        err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultLoadBalancer, err
}

// Read is API call with trace log
func (t *LoadBalancerTracer) Read(ctx context.Context, zone string, id types.ID) (*sacloud.LoadBalancer, error) {
	log.Println("[TRACE] LoadBalancerAPI.Read start")
	targetArguments := struct {
		Argzone string
		Argid   types.ID `json:"id"`
	}{
		Argzone: zone,
		Argid:   id,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] LoadBalancerAPI.Read end")
	}()

	resultLoadBalancer, err := t.Internal.Read(ctx, zone, id)
	targetResults := struct {
		LoadBalancer *sacloud.LoadBalancer
		Error        error
	}{
		LoadBalancer: resultLoadBalancer,
		Error:        err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultLoadBalancer, err
}

// Update is API call with trace log
func (t *LoadBalancerTracer) Update(ctx context.Context, zone string, id types.ID, param *sacloud.LoadBalancerUpdateRequest) (*sacloud.LoadBalancer, error) {
	log.Println("[TRACE] LoadBalancerAPI.Update start")
	targetArguments := struct {
		Argzone  string
		Argid    types.ID                           `json:"id"`
		Argparam *sacloud.LoadBalancerUpdateRequest `json:"param"`
	}{
		Argzone:  zone,
		Argid:    id,
		Argparam: param,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] LoadBalancerAPI.Update end")
	}()

	resultLoadBalancer, err := t.Internal.Update(ctx, zone, id, param)
	targetResults := struct {
		LoadBalancer *sacloud.LoadBalancer
		Error        error
	}{
		LoadBalancer: resultLoadBalancer,
		Error:        err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultLoadBalancer, err
}

// UpdateSettings is API call with trace log
func (t *LoadBalancerTracer) UpdateSettings(ctx context.Context, zone string, id types.ID, param *sacloud.LoadBalancerUpdateSettingsRequest) (*sacloud.LoadBalancer, error) {
	log.Println("[TRACE] LoadBalancerAPI.UpdateSettings start")
	targetArguments := struct {
		Argzone  string
		Argid    types.ID                                   `json:"id"`
		Argparam *sacloud.LoadBalancerUpdateSettingsRequest `json:"param"`
	}{
		Argzone:  zone,
		Argid:    id,
		Argparam: param,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] LoadBalancerAPI.UpdateSettings end")
	}()

	resultLoadBalancer, err := t.Internal.UpdateSettings(ctx, zone, id, param)
	targetResults := struct {
		LoadBalancer *sacloud.LoadBalancer
		Error        error
	}{
		LoadBalancer: resultLoadBalancer,
		Error:        err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultLoadBalancer, err
}

// Delete is API call with trace log
func (t *LoadBalancerTracer) Delete(ctx context.Context, zone string, id types.ID) error {
	log.Println("[TRACE] LoadBalancerAPI.Delete start")
	targetArguments := struct {
		Argzone string
		Argid   types.ID `json:"id"`
	}{
		Argzone: zone,
		Argid:   id,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] LoadBalancerAPI.Delete end")
	}()

	err := t.Internal.Delete(ctx, zone, id)
	targetResults := struct {
		Error error
	}{
		Error: err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return err
}

// Config is API call with trace log
func (t *LoadBalancerTracer) Config(ctx context.Context, zone string, id types.ID) error {
	log.Println("[TRACE] LoadBalancerAPI.Config start")
	targetArguments := struct {
		Argzone string
		Argid   types.ID `json:"id"`
	}{
		Argzone: zone,
		Argid:   id,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] LoadBalancerAPI.Config end")
	}()

	err := t.Internal.Config(ctx, zone, id)
	targetResults := struct {
		Error error
	}{
		Error: err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return err
}

// Boot is API call with trace log
func (t *LoadBalancerTracer) Boot(ctx context.Context, zone string, id types.ID) error {
	log.Println("[TRACE] LoadBalancerAPI.Boot start")
	targetArguments := struct {
		Argzone string
		Argid   types.ID `json:"id"`
	}{
		Argzone: zone,
		Argid:   id,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] LoadBalancerAPI.Boot end")
	}()

	err := t.Internal.Boot(ctx, zone, id)
	targetResults := struct {
		Error error
	}{
		Error: err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return err
}

// Shutdown is API call with trace log
func (t *LoadBalancerTracer) Shutdown(ctx context.Context, zone string, id types.ID, shutdownOption *sacloud.ShutdownOption) error {
	log.Println("[TRACE] LoadBalancerAPI.Shutdown start")
	targetArguments := struct {
		Argzone           string
		Argid             types.ID                `json:"id"`
		ArgshutdownOption *sacloud.ShutdownOption `json:"shutdownOption"`
	}{
		Argzone:           zone,
		Argid:             id,
		ArgshutdownOption: shutdownOption,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] LoadBalancerAPI.Shutdown end")
	}()

	err := t.Internal.Shutdown(ctx, zone, id, shutdownOption)
	targetResults := struct {
		Error error
	}{
		Error: err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return err
}

// Reset is API call with trace log
func (t *LoadBalancerTracer) Reset(ctx context.Context, zone string, id types.ID) error {
	log.Println("[TRACE] LoadBalancerAPI.Reset start")
	targetArguments := struct {
		Argzone string
		Argid   types.ID `json:"id"`
	}{
		Argzone: zone,
		Argid:   id,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] LoadBalancerAPI.Reset end")
	}()

	err := t.Internal.Reset(ctx, zone, id)
	targetResults := struct {
		Error error
	}{
		Error: err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return err
}

// MonitorCPU is API call with trace log
func (t *LoadBalancerTracer) MonitorCPU(ctx context.Context, zone string, id types.ID, condition *sacloud.MonitorCondition) (*sacloud.CPUTimeActivity, error) {
	log.Println("[TRACE] LoadBalancerAPI.MonitorCPU start")
	targetArguments := struct {
		Argzone      string
		Argid        types.ID                  `json:"id"`
		Argcondition *sacloud.MonitorCondition `json:"condition"`
	}{
		Argzone:      zone,
		Argid:        id,
		Argcondition: condition,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] LoadBalancerAPI.MonitorCPU end")
	}()

	resultCPUTimeActivity, err := t.Internal.MonitorCPU(ctx, zone, id, condition)
	targetResults := struct {
		CPUTimeActivity *sacloud.CPUTimeActivity
		Error           error
	}{
		CPUTimeActivity: resultCPUTimeActivity,
		Error:           err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultCPUTimeActivity, err
}

// MonitorInterface is API call with trace log
func (t *LoadBalancerTracer) MonitorInterface(ctx context.Context, zone string, id types.ID, condition *sacloud.MonitorCondition) (*sacloud.InterfaceActivity, error) {
	log.Println("[TRACE] LoadBalancerAPI.MonitorInterface start")
	targetArguments := struct {
		Argzone      string
		Argid        types.ID                  `json:"id"`
		Argcondition *sacloud.MonitorCondition `json:"condition"`
	}{
		Argzone:      zone,
		Argid:        id,
		Argcondition: condition,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] LoadBalancerAPI.MonitorInterface end")
	}()

	resultInterfaceActivity, err := t.Internal.MonitorInterface(ctx, zone, id, condition)
	targetResults := struct {
		InterfaceActivity *sacloud.InterfaceActivity
		Error             error
	}{
		InterfaceActivity: resultInterfaceActivity,
		Error:             err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultInterfaceActivity, err
}

// Status is API call with trace log
func (t *LoadBalancerTracer) Status(ctx context.Context, zone string, id types.ID) (*sacloud.LoadBalancerStatusResult, error) {
	log.Println("[TRACE] LoadBalancerAPI.Status start")
	targetArguments := struct {
		Argzone string
		Argid   types.ID `json:"id"`
	}{
		Argzone: zone,
		Argid:   id,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] LoadBalancerAPI.Status end")
	}()

	result, err := t.Internal.Status(ctx, zone, id)
	targetResults := struct {
		Result *sacloud.LoadBalancerStatusResult
		Error  error
	}{
		Result: result,
		Error:  err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return result, err
}

/*************************************************
* LocalRouterTracer
*************************************************/

// LocalRouterTracer is for trace LocalRouterOp operations
type LocalRouterTracer struct {
	Internal sacloud.LocalRouterAPI
}

// NewLocalRouterTracer creates new LocalRouterTracer instance
func NewLocalRouterTracer(in sacloud.LocalRouterAPI) sacloud.LocalRouterAPI {
	return &LocalRouterTracer{
		Internal: in,
	}
}

// Find is API call with trace log
func (t *LocalRouterTracer) Find(ctx context.Context, conditions *sacloud.FindCondition) (*sacloud.LocalRouterFindResult, error) {
	log.Println("[TRACE] LocalRouterAPI.Find start")
	targetArguments := struct {
		Argconditions *sacloud.FindCondition `json:"conditions"`
	}{
		Argconditions: conditions,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] LocalRouterAPI.Find end")
	}()

	result, err := t.Internal.Find(ctx, conditions)
	targetResults := struct {
		Result *sacloud.LocalRouterFindResult
		Error  error
	}{
		Result: result,
		Error:  err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return result, err
}

// Create is API call with trace log
func (t *LocalRouterTracer) Create(ctx context.Context, param *sacloud.LocalRouterCreateRequest) (*sacloud.LocalRouter, error) {
	log.Println("[TRACE] LocalRouterAPI.Create start")
	targetArguments := struct {
		Argparam *sacloud.LocalRouterCreateRequest `json:"param"`
	}{
		Argparam: param,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] LocalRouterAPI.Create end")
	}()

	resultLocalRouter, err := t.Internal.Create(ctx, param)
	targetResults := struct {
		LocalRouter *sacloud.LocalRouter
		Error       error
	}{
		LocalRouter: resultLocalRouter,
		Error:       err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultLocalRouter, err
}

// Read is API call with trace log
func (t *LocalRouterTracer) Read(ctx context.Context, id types.ID) (*sacloud.LocalRouter, error) {
	log.Println("[TRACE] LocalRouterAPI.Read start")
	targetArguments := struct {
		Argid types.ID `json:"id"`
	}{
		Argid: id,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] LocalRouterAPI.Read end")
	}()

	resultLocalRouter, err := t.Internal.Read(ctx, id)
	targetResults := struct {
		LocalRouter *sacloud.LocalRouter
		Error       error
	}{
		LocalRouter: resultLocalRouter,
		Error:       err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultLocalRouter, err
}

// Update is API call with trace log
func (t *LocalRouterTracer) Update(ctx context.Context, id types.ID, param *sacloud.LocalRouterUpdateRequest) (*sacloud.LocalRouter, error) {
	log.Println("[TRACE] LocalRouterAPI.Update start")
	targetArguments := struct {
		Argid    types.ID                          `json:"id"`
		Argparam *sacloud.LocalRouterUpdateRequest `json:"param"`
	}{
		Argid:    id,
		Argparam: param,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] LocalRouterAPI.Update end")
	}()

	resultLocalRouter, err := t.Internal.Update(ctx, id, param)
	targetResults := struct {
		LocalRouter *sacloud.LocalRouter
		Error       error
	}{
		LocalRouter: resultLocalRouter,
		Error:       err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultLocalRouter, err
}

// UpdateSettings is API call with trace log
func (t *LocalRouterTracer) UpdateSettings(ctx context.Context, id types.ID, param *sacloud.LocalRouterUpdateSettingsRequest) (*sacloud.LocalRouter, error) {
	log.Println("[TRACE] LocalRouterAPI.UpdateSettings start")
	targetArguments := struct {
		Argid    types.ID                                  `json:"id"`
		Argparam *sacloud.LocalRouterUpdateSettingsRequest `json:"param"`
	}{
		Argid:    id,
		Argparam: param,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] LocalRouterAPI.UpdateSettings end")
	}()

	resultLocalRouter, err := t.Internal.UpdateSettings(ctx, id, param)
	targetResults := struct {
		LocalRouter *sacloud.LocalRouter
		Error       error
	}{
		LocalRouter: resultLocalRouter,
		Error:       err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultLocalRouter, err
}

// Delete is API call with trace log
func (t *LocalRouterTracer) Delete(ctx context.Context, id types.ID) error {
	log.Println("[TRACE] LocalRouterAPI.Delete start")
	targetArguments := struct {
		Argid types.ID `json:"id"`
	}{
		Argid: id,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] LocalRouterAPI.Delete end")
	}()

	err := t.Internal.Delete(ctx, id)
	targetResults := struct {
		Error error
	}{
		Error: err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return err
}

// HealthStatus is API call with trace log
func (t *LocalRouterTracer) HealthStatus(ctx context.Context, id types.ID) (*sacloud.LocalRouterHealth, error) {
	log.Println("[TRACE] LocalRouterAPI.HealthStatus start")
	targetArguments := struct {
		Argid types.ID `json:"id"`
	}{
		Argid: id,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] LocalRouterAPI.HealthStatus end")
	}()

	resultLocalRouterHealth, err := t.Internal.HealthStatus(ctx, id)
	targetResults := struct {
		LocalRouterHealth *sacloud.LocalRouterHealth
		Error             error
	}{
		LocalRouterHealth: resultLocalRouterHealth,
		Error:             err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultLocalRouterHealth, err
}

// MonitorLocalRouter is API call with trace log
func (t *LocalRouterTracer) MonitorLocalRouter(ctx context.Context, id types.ID, condition *sacloud.MonitorCondition) (*sacloud.LocalRouterActivity, error) {
	log.Println("[TRACE] LocalRouterAPI.MonitorLocalRouter start")
	targetArguments := struct {
		Argid        types.ID                  `json:"id"`
		Argcondition *sacloud.MonitorCondition `json:"condition"`
	}{
		Argid:        id,
		Argcondition: condition,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] LocalRouterAPI.MonitorLocalRouter end")
	}()

	resultLocalRouterActivity, err := t.Internal.MonitorLocalRouter(ctx, id, condition)
	targetResults := struct {
		LocalRouterActivity *sacloud.LocalRouterActivity
		Error               error
	}{
		LocalRouterActivity: resultLocalRouterActivity,
		Error:               err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultLocalRouterActivity, err
}

/*************************************************
* MobileGatewayTracer
*************************************************/

// MobileGatewayTracer is for trace MobileGatewayOp operations
type MobileGatewayTracer struct {
	Internal sacloud.MobileGatewayAPI
}

// NewMobileGatewayTracer creates new MobileGatewayTracer instance
func NewMobileGatewayTracer(in sacloud.MobileGatewayAPI) sacloud.MobileGatewayAPI {
	return &MobileGatewayTracer{
		Internal: in,
	}
}

// Find is API call with trace log
func (t *MobileGatewayTracer) Find(ctx context.Context, zone string, conditions *sacloud.FindCondition) (*sacloud.MobileGatewayFindResult, error) {
	log.Println("[TRACE] MobileGatewayAPI.Find start")
	targetArguments := struct {
		Argzone       string
		Argconditions *sacloud.FindCondition `json:"conditions"`
	}{
		Argzone:       zone,
		Argconditions: conditions,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] MobileGatewayAPI.Find end")
	}()

	result, err := t.Internal.Find(ctx, zone, conditions)
	targetResults := struct {
		Result *sacloud.MobileGatewayFindResult
		Error  error
	}{
		Result: result,
		Error:  err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return result, err
}

// Create is API call with trace log
func (t *MobileGatewayTracer) Create(ctx context.Context, zone string, param *sacloud.MobileGatewayCreateRequest) (*sacloud.MobileGateway, error) {
	log.Println("[TRACE] MobileGatewayAPI.Create start")
	targetArguments := struct {
		Argzone  string
		Argparam *sacloud.MobileGatewayCreateRequest `json:"param"`
	}{
		Argzone:  zone,
		Argparam: param,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] MobileGatewayAPI.Create end")
	}()

	resultMobileGateway, err := t.Internal.Create(ctx, zone, param)
	targetResults := struct {
		MobileGateway *sacloud.MobileGateway
		Error         error
	}{
		MobileGateway: resultMobileGateway,
		Error:         err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultMobileGateway, err
}

// Read is API call with trace log
func (t *MobileGatewayTracer) Read(ctx context.Context, zone string, id types.ID) (*sacloud.MobileGateway, error) {
	log.Println("[TRACE] MobileGatewayAPI.Read start")
	targetArguments := struct {
		Argzone string
		Argid   types.ID `json:"id"`
	}{
		Argzone: zone,
		Argid:   id,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] MobileGatewayAPI.Read end")
	}()

	resultMobileGateway, err := t.Internal.Read(ctx, zone, id)
	targetResults := struct {
		MobileGateway *sacloud.MobileGateway
		Error         error
	}{
		MobileGateway: resultMobileGateway,
		Error:         err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultMobileGateway, err
}

// Update is API call with trace log
func (t *MobileGatewayTracer) Update(ctx context.Context, zone string, id types.ID, param *sacloud.MobileGatewayUpdateRequest) (*sacloud.MobileGateway, error) {
	log.Println("[TRACE] MobileGatewayAPI.Update start")
	targetArguments := struct {
		Argzone  string
		Argid    types.ID                            `json:"id"`
		Argparam *sacloud.MobileGatewayUpdateRequest `json:"param"`
	}{
		Argzone:  zone,
		Argid:    id,
		Argparam: param,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] MobileGatewayAPI.Update end")
	}()

	resultMobileGateway, err := t.Internal.Update(ctx, zone, id, param)
	targetResults := struct {
		MobileGateway *sacloud.MobileGateway
		Error         error
	}{
		MobileGateway: resultMobileGateway,
		Error:         err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultMobileGateway, err
}

// UpdateSettings is API call with trace log
func (t *MobileGatewayTracer) UpdateSettings(ctx context.Context, zone string, id types.ID, param *sacloud.MobileGatewayUpdateSettingsRequest) (*sacloud.MobileGateway, error) {
	log.Println("[TRACE] MobileGatewayAPI.UpdateSettings start")
	targetArguments := struct {
		Argzone  string
		Argid    types.ID                                    `json:"id"`
		Argparam *sacloud.MobileGatewayUpdateSettingsRequest `json:"param"`
	}{
		Argzone:  zone,
		Argid:    id,
		Argparam: param,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] MobileGatewayAPI.UpdateSettings end")
	}()

	resultMobileGateway, err := t.Internal.UpdateSettings(ctx, zone, id, param)
	targetResults := struct {
		MobileGateway *sacloud.MobileGateway
		Error         error
	}{
		MobileGateway: resultMobileGateway,
		Error:         err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultMobileGateway, err
}

// Delete is API call with trace log
func (t *MobileGatewayTracer) Delete(ctx context.Context, zone string, id types.ID) error {
	log.Println("[TRACE] MobileGatewayAPI.Delete start")
	targetArguments := struct {
		Argzone string
		Argid   types.ID `json:"id"`
	}{
		Argzone: zone,
		Argid:   id,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] MobileGatewayAPI.Delete end")
	}()

	err := t.Internal.Delete(ctx, zone, id)
	targetResults := struct {
		Error error
	}{
		Error: err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return err
}

// Config is API call with trace log
func (t *MobileGatewayTracer) Config(ctx context.Context, zone string, id types.ID) error {
	log.Println("[TRACE] MobileGatewayAPI.Config start")
	targetArguments := struct {
		Argzone string
		Argid   types.ID `json:"id"`
	}{
		Argzone: zone,
		Argid:   id,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] MobileGatewayAPI.Config end")
	}()

	err := t.Internal.Config(ctx, zone, id)
	targetResults := struct {
		Error error
	}{
		Error: err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return err
}

// Boot is API call with trace log
func (t *MobileGatewayTracer) Boot(ctx context.Context, zone string, id types.ID) error {
	log.Println("[TRACE] MobileGatewayAPI.Boot start")
	targetArguments := struct {
		Argzone string
		Argid   types.ID `json:"id"`
	}{
		Argzone: zone,
		Argid:   id,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] MobileGatewayAPI.Boot end")
	}()

	err := t.Internal.Boot(ctx, zone, id)
	targetResults := struct {
		Error error
	}{
		Error: err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return err
}

// Shutdown is API call with trace log
func (t *MobileGatewayTracer) Shutdown(ctx context.Context, zone string, id types.ID, shutdownOption *sacloud.ShutdownOption) error {
	log.Println("[TRACE] MobileGatewayAPI.Shutdown start")
	targetArguments := struct {
		Argzone           string
		Argid             types.ID                `json:"id"`
		ArgshutdownOption *sacloud.ShutdownOption `json:"shutdownOption"`
	}{
		Argzone:           zone,
		Argid:             id,
		ArgshutdownOption: shutdownOption,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] MobileGatewayAPI.Shutdown end")
	}()

	err := t.Internal.Shutdown(ctx, zone, id, shutdownOption)
	targetResults := struct {
		Error error
	}{
		Error: err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return err
}

// Reset is API call with trace log
func (t *MobileGatewayTracer) Reset(ctx context.Context, zone string, id types.ID) error {
	log.Println("[TRACE] MobileGatewayAPI.Reset start")
	targetArguments := struct {
		Argzone string
		Argid   types.ID `json:"id"`
	}{
		Argzone: zone,
		Argid:   id,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] MobileGatewayAPI.Reset end")
	}()

	err := t.Internal.Reset(ctx, zone, id)
	targetResults := struct {
		Error error
	}{
		Error: err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return err
}

// ConnectToSwitch is API call with trace log
func (t *MobileGatewayTracer) ConnectToSwitch(ctx context.Context, zone string, id types.ID, switchID types.ID) error {
	log.Println("[TRACE] MobileGatewayAPI.ConnectToSwitch start")
	targetArguments := struct {
		Argzone     string
		Argid       types.ID `json:"id"`
		ArgswitchID types.ID `json:"switchID"`
	}{
		Argzone:     zone,
		Argid:       id,
		ArgswitchID: switchID,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] MobileGatewayAPI.ConnectToSwitch end")
	}()

	err := t.Internal.ConnectToSwitch(ctx, zone, id, switchID)
	targetResults := struct {
		Error error
	}{
		Error: err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return err
}

// DisconnectFromSwitch is API call with trace log
func (t *MobileGatewayTracer) DisconnectFromSwitch(ctx context.Context, zone string, id types.ID) error {
	log.Println("[TRACE] MobileGatewayAPI.DisconnectFromSwitch start")
	targetArguments := struct {
		Argzone string
		Argid   types.ID `json:"id"`
	}{
		Argzone: zone,
		Argid:   id,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] MobileGatewayAPI.DisconnectFromSwitch end")
	}()

	err := t.Internal.DisconnectFromSwitch(ctx, zone, id)
	targetResults := struct {
		Error error
	}{
		Error: err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return err
}

// GetDNS is API call with trace log
func (t *MobileGatewayTracer) GetDNS(ctx context.Context, zone string, id types.ID) (*sacloud.MobileGatewayDNSSetting, error) {
	log.Println("[TRACE] MobileGatewayAPI.GetDNS start")
	targetArguments := struct {
		Argzone string
		Argid   types.ID `json:"id"`
	}{
		Argzone: zone,
		Argid:   id,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] MobileGatewayAPI.GetDNS end")
	}()

	resultSIMGroup, err := t.Internal.GetDNS(ctx, zone, id)
	targetResults := struct {
		SIMGroup *sacloud.MobileGatewayDNSSetting
		Error    error
	}{
		SIMGroup: resultSIMGroup,
		Error:    err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultSIMGroup, err
}

// SetDNS is API call with trace log
func (t *MobileGatewayTracer) SetDNS(ctx context.Context, zone string, id types.ID, param *sacloud.MobileGatewayDNSSetting) error {
	log.Println("[TRACE] MobileGatewayAPI.SetDNS start")
	targetArguments := struct {
		Argzone  string
		Argid    types.ID                         `json:"id"`
		Argparam *sacloud.MobileGatewayDNSSetting `json:"param"`
	}{
		Argzone:  zone,
		Argid:    id,
		Argparam: param,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] MobileGatewayAPI.SetDNS end")
	}()

	err := t.Internal.SetDNS(ctx, zone, id, param)
	targetResults := struct {
		Error error
	}{
		Error: err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return err
}

// GetSIMRoutes is API call with trace log
func (t *MobileGatewayTracer) GetSIMRoutes(ctx context.Context, zone string, id types.ID) (sacloud.MobileGatewaySIMRoutes, error) {
	log.Println("[TRACE] MobileGatewayAPI.GetSIMRoutes start")
	targetArguments := struct {
		Argzone string
		Argid   types.ID `json:"id"`
	}{
		Argzone: zone,
		Argid:   id,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] MobileGatewayAPI.GetSIMRoutes end")
	}()

	resultSIMRoutes, err := t.Internal.GetSIMRoutes(ctx, zone, id)
	targetResults := struct {
		SIMRoutes sacloud.MobileGatewaySIMRoutes
		Error     error
	}{
		SIMRoutes: resultSIMRoutes,
		Error:     err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultSIMRoutes, err
}

// SetSIMRoutes is API call with trace log
func (t *MobileGatewayTracer) SetSIMRoutes(ctx context.Context, zone string, id types.ID, param []*sacloud.MobileGatewaySIMRouteParam) error {
	log.Println("[TRACE] MobileGatewayAPI.SetSIMRoutes start")
	targetArguments := struct {
		Argzone  string
		Argid    types.ID                              `json:"id"`
		Argparam []*sacloud.MobileGatewaySIMRouteParam `json:"param"`
	}{
		Argzone:  zone,
		Argid:    id,
		Argparam: param,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] MobileGatewayAPI.SetSIMRoutes end")
	}()

	err := t.Internal.SetSIMRoutes(ctx, zone, id, param)
	targetResults := struct {
		Error error
	}{
		Error: err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return err
}

// ListSIM is API call with trace log
func (t *MobileGatewayTracer) ListSIM(ctx context.Context, zone string, id types.ID) (sacloud.MobileGatewaySIMs, error) {
	log.Println("[TRACE] MobileGatewayAPI.ListSIM start")
	targetArguments := struct {
		Argzone string
		Argid   types.ID `json:"id"`
	}{
		Argzone: zone,
		Argid:   id,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] MobileGatewayAPI.ListSIM end")
	}()

	resultSIM, err := t.Internal.ListSIM(ctx, zone, id)
	targetResults := struct {
		SIM   sacloud.MobileGatewaySIMs
		Error error
	}{
		SIM:   resultSIM,
		Error: err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultSIM, err
}

// AddSIM is API call with trace log
func (t *MobileGatewayTracer) AddSIM(ctx context.Context, zone string, id types.ID, param *sacloud.MobileGatewayAddSIMRequest) error {
	log.Println("[TRACE] MobileGatewayAPI.AddSIM start")
	targetArguments := struct {
		Argzone  string
		Argid    types.ID                            `json:"id"`
		Argparam *sacloud.MobileGatewayAddSIMRequest `json:"param"`
	}{
		Argzone:  zone,
		Argid:    id,
		Argparam: param,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] MobileGatewayAPI.AddSIM end")
	}()

	err := t.Internal.AddSIM(ctx, zone, id, param)
	targetResults := struct {
		Error error
	}{
		Error: err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return err
}

// DeleteSIM is API call with trace log
func (t *MobileGatewayTracer) DeleteSIM(ctx context.Context, zone string, id types.ID, simID types.ID) error {
	log.Println("[TRACE] MobileGatewayAPI.DeleteSIM start")
	targetArguments := struct {
		Argzone  string
		Argid    types.ID `json:"id"`
		ArgsimID types.ID `json:"simID"`
	}{
		Argzone:  zone,
		Argid:    id,
		ArgsimID: simID,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] MobileGatewayAPI.DeleteSIM end")
	}()

	err := t.Internal.DeleteSIM(ctx, zone, id, simID)
	targetResults := struct {
		Error error
	}{
		Error: err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return err
}

// Logs is API call with trace log
func (t *MobileGatewayTracer) Logs(ctx context.Context, zone string, id types.ID) ([]*sacloud.MobileGatewaySIMLogs, error) {
	log.Println("[TRACE] MobileGatewayAPI.Logs start")
	targetArguments := struct {
		Argzone string
		Argid   types.ID `json:"id"`
	}{
		Argzone: zone,
		Argid:   id,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] MobileGatewayAPI.Logs end")
	}()

	resultLogs, err := t.Internal.Logs(ctx, zone, id)
	targetResults := struct {
		Logs  []*sacloud.MobileGatewaySIMLogs
		Error error
	}{
		Logs:  resultLogs,
		Error: err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultLogs, err
}

// GetTrafficConfig is API call with trace log
func (t *MobileGatewayTracer) GetTrafficConfig(ctx context.Context, zone string, id types.ID) (*sacloud.MobileGatewayTrafficControl, error) {
	log.Println("[TRACE] MobileGatewayAPI.GetTrafficConfig start")
	targetArguments := struct {
		Argzone string
		Argid   types.ID `json:"id"`
	}{
		Argzone: zone,
		Argid:   id,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] MobileGatewayAPI.GetTrafficConfig end")
	}()

	resultTrafficMonitoring, err := t.Internal.GetTrafficConfig(ctx, zone, id)
	targetResults := struct {
		TrafficMonitoring *sacloud.MobileGatewayTrafficControl
		Error             error
	}{
		TrafficMonitoring: resultTrafficMonitoring,
		Error:             err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultTrafficMonitoring, err
}

// SetTrafficConfig is API call with trace log
func (t *MobileGatewayTracer) SetTrafficConfig(ctx context.Context, zone string, id types.ID, param *sacloud.MobileGatewayTrafficControl) error {
	log.Println("[TRACE] MobileGatewayAPI.SetTrafficConfig start")
	targetArguments := struct {
		Argzone  string
		Argid    types.ID                             `json:"id"`
		Argparam *sacloud.MobileGatewayTrafficControl `json:"param"`
	}{
		Argzone:  zone,
		Argid:    id,
		Argparam: param,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] MobileGatewayAPI.SetTrafficConfig end")
	}()

	err := t.Internal.SetTrafficConfig(ctx, zone, id, param)
	targetResults := struct {
		Error error
	}{
		Error: err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return err
}

// DeleteTrafficConfig is API call with trace log
func (t *MobileGatewayTracer) DeleteTrafficConfig(ctx context.Context, zone string, id types.ID) error {
	log.Println("[TRACE] MobileGatewayAPI.DeleteTrafficConfig start")
	targetArguments := struct {
		Argzone string
		Argid   types.ID `json:"id"`
	}{
		Argzone: zone,
		Argid:   id,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] MobileGatewayAPI.DeleteTrafficConfig end")
	}()

	err := t.Internal.DeleteTrafficConfig(ctx, zone, id)
	targetResults := struct {
		Error error
	}{
		Error: err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return err
}

// TrafficStatus is API call with trace log
func (t *MobileGatewayTracer) TrafficStatus(ctx context.Context, zone string, id types.ID) (*sacloud.MobileGatewayTrafficStatus, error) {
	log.Println("[TRACE] MobileGatewayAPI.TrafficStatus start")
	targetArguments := struct {
		Argzone string
		Argid   types.ID `json:"id"`
	}{
		Argzone: zone,
		Argid:   id,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] MobileGatewayAPI.TrafficStatus end")
	}()

	resultTrafficStatus, err := t.Internal.TrafficStatus(ctx, zone, id)
	targetResults := struct {
		TrafficStatus *sacloud.MobileGatewayTrafficStatus
		Error         error
	}{
		TrafficStatus: resultTrafficStatus,
		Error:         err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultTrafficStatus, err
}

// MonitorInterface is API call with trace log
func (t *MobileGatewayTracer) MonitorInterface(ctx context.Context, zone string, id types.ID, index int, condition *sacloud.MonitorCondition) (*sacloud.InterfaceActivity, error) {
	log.Println("[TRACE] MobileGatewayAPI.MonitorInterface start")
	targetArguments := struct {
		Argzone      string
		Argid        types.ID                  `json:"id"`
		Argindex     int                       `json:"index"`
		Argcondition *sacloud.MonitorCondition `json:"condition"`
	}{
		Argzone:      zone,
		Argid:        id,
		Argindex:     index,
		Argcondition: condition,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] MobileGatewayAPI.MonitorInterface end")
	}()

	resultInterfaceActivity, err := t.Internal.MonitorInterface(ctx, zone, id, index, condition)
	targetResults := struct {
		InterfaceActivity *sacloud.InterfaceActivity
		Error             error
	}{
		InterfaceActivity: resultInterfaceActivity,
		Error:             err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultInterfaceActivity, err
}

/*************************************************
* NFSTracer
*************************************************/

// NFSTracer is for trace NFSOp operations
type NFSTracer struct {
	Internal sacloud.NFSAPI
}

// NewNFSTracer creates new NFSTracer instance
func NewNFSTracer(in sacloud.NFSAPI) sacloud.NFSAPI {
	return &NFSTracer{
		Internal: in,
	}
}

// Find is API call with trace log
func (t *NFSTracer) Find(ctx context.Context, zone string, conditions *sacloud.FindCondition) (*sacloud.NFSFindResult, error) {
	log.Println("[TRACE] NFSAPI.Find start")
	targetArguments := struct {
		Argzone       string
		Argconditions *sacloud.FindCondition `json:"conditions"`
	}{
		Argzone:       zone,
		Argconditions: conditions,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] NFSAPI.Find end")
	}()

	result, err := t.Internal.Find(ctx, zone, conditions)
	targetResults := struct {
		Result *sacloud.NFSFindResult
		Error  error
	}{
		Result: result,
		Error:  err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return result, err
}

// Create is API call with trace log
func (t *NFSTracer) Create(ctx context.Context, zone string, param *sacloud.NFSCreateRequest) (*sacloud.NFS, error) {
	log.Println("[TRACE] NFSAPI.Create start")
	targetArguments := struct {
		Argzone  string
		Argparam *sacloud.NFSCreateRequest `json:"param"`
	}{
		Argzone:  zone,
		Argparam: param,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] NFSAPI.Create end")
	}()

	resultNFS, err := t.Internal.Create(ctx, zone, param)
	targetResults := struct {
		NFS   *sacloud.NFS
		Error error
	}{
		NFS:   resultNFS,
		Error: err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultNFS, err
}

// Read is API call with trace log
func (t *NFSTracer) Read(ctx context.Context, zone string, id types.ID) (*sacloud.NFS, error) {
	log.Println("[TRACE] NFSAPI.Read start")
	targetArguments := struct {
		Argzone string
		Argid   types.ID `json:"id"`
	}{
		Argzone: zone,
		Argid:   id,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] NFSAPI.Read end")
	}()

	resultNFS, err := t.Internal.Read(ctx, zone, id)
	targetResults := struct {
		NFS   *sacloud.NFS
		Error error
	}{
		NFS:   resultNFS,
		Error: err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultNFS, err
}

// Update is API call with trace log
func (t *NFSTracer) Update(ctx context.Context, zone string, id types.ID, param *sacloud.NFSUpdateRequest) (*sacloud.NFS, error) {
	log.Println("[TRACE] NFSAPI.Update start")
	targetArguments := struct {
		Argzone  string
		Argid    types.ID                  `json:"id"`
		Argparam *sacloud.NFSUpdateRequest `json:"param"`
	}{
		Argzone:  zone,
		Argid:    id,
		Argparam: param,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] NFSAPI.Update end")
	}()

	resultNFS, err := t.Internal.Update(ctx, zone, id, param)
	targetResults := struct {
		NFS   *sacloud.NFS
		Error error
	}{
		NFS:   resultNFS,
		Error: err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultNFS, err
}

// Delete is API call with trace log
func (t *NFSTracer) Delete(ctx context.Context, zone string, id types.ID) error {
	log.Println("[TRACE] NFSAPI.Delete start")
	targetArguments := struct {
		Argzone string
		Argid   types.ID `json:"id"`
	}{
		Argzone: zone,
		Argid:   id,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] NFSAPI.Delete end")
	}()

	err := t.Internal.Delete(ctx, zone, id)
	targetResults := struct {
		Error error
	}{
		Error: err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return err
}

// Boot is API call with trace log
func (t *NFSTracer) Boot(ctx context.Context, zone string, id types.ID) error {
	log.Println("[TRACE] NFSAPI.Boot start")
	targetArguments := struct {
		Argzone string
		Argid   types.ID `json:"id"`
	}{
		Argzone: zone,
		Argid:   id,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] NFSAPI.Boot end")
	}()

	err := t.Internal.Boot(ctx, zone, id)
	targetResults := struct {
		Error error
	}{
		Error: err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return err
}

// Shutdown is API call with trace log
func (t *NFSTracer) Shutdown(ctx context.Context, zone string, id types.ID, shutdownOption *sacloud.ShutdownOption) error {
	log.Println("[TRACE] NFSAPI.Shutdown start")
	targetArguments := struct {
		Argzone           string
		Argid             types.ID                `json:"id"`
		ArgshutdownOption *sacloud.ShutdownOption `json:"shutdownOption"`
	}{
		Argzone:           zone,
		Argid:             id,
		ArgshutdownOption: shutdownOption,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] NFSAPI.Shutdown end")
	}()

	err := t.Internal.Shutdown(ctx, zone, id, shutdownOption)
	targetResults := struct {
		Error error
	}{
		Error: err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return err
}

// Reset is API call with trace log
func (t *NFSTracer) Reset(ctx context.Context, zone string, id types.ID) error {
	log.Println("[TRACE] NFSAPI.Reset start")
	targetArguments := struct {
		Argzone string
		Argid   types.ID `json:"id"`
	}{
		Argzone: zone,
		Argid:   id,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] NFSAPI.Reset end")
	}()

	err := t.Internal.Reset(ctx, zone, id)
	targetResults := struct {
		Error error
	}{
		Error: err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return err
}

// MonitorCPU is API call with trace log
func (t *NFSTracer) MonitorCPU(ctx context.Context, zone string, id types.ID, condition *sacloud.MonitorCondition) (*sacloud.CPUTimeActivity, error) {
	log.Println("[TRACE] NFSAPI.MonitorCPU start")
	targetArguments := struct {
		Argzone      string
		Argid        types.ID                  `json:"id"`
		Argcondition *sacloud.MonitorCondition `json:"condition"`
	}{
		Argzone:      zone,
		Argid:        id,
		Argcondition: condition,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] NFSAPI.MonitorCPU end")
	}()

	resultCPUTimeActivity, err := t.Internal.MonitorCPU(ctx, zone, id, condition)
	targetResults := struct {
		CPUTimeActivity *sacloud.CPUTimeActivity
		Error           error
	}{
		CPUTimeActivity: resultCPUTimeActivity,
		Error:           err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultCPUTimeActivity, err
}

// MonitorFreeDiskSize is API call with trace log
func (t *NFSTracer) MonitorFreeDiskSize(ctx context.Context, zone string, id types.ID, condition *sacloud.MonitorCondition) (*sacloud.FreeDiskSizeActivity, error) {
	log.Println("[TRACE] NFSAPI.MonitorFreeDiskSize start")
	targetArguments := struct {
		Argzone      string
		Argid        types.ID                  `json:"id"`
		Argcondition *sacloud.MonitorCondition `json:"condition"`
	}{
		Argzone:      zone,
		Argid:        id,
		Argcondition: condition,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] NFSAPI.MonitorFreeDiskSize end")
	}()

	resultFreeDiskSizeActivity, err := t.Internal.MonitorFreeDiskSize(ctx, zone, id, condition)
	targetResults := struct {
		FreeDiskSizeActivity *sacloud.FreeDiskSizeActivity
		Error                error
	}{
		FreeDiskSizeActivity: resultFreeDiskSizeActivity,
		Error:                err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultFreeDiskSizeActivity, err
}

// MonitorInterface is API call with trace log
func (t *NFSTracer) MonitorInterface(ctx context.Context, zone string, id types.ID, condition *sacloud.MonitorCondition) (*sacloud.InterfaceActivity, error) {
	log.Println("[TRACE] NFSAPI.MonitorInterface start")
	targetArguments := struct {
		Argzone      string
		Argid        types.ID                  `json:"id"`
		Argcondition *sacloud.MonitorCondition `json:"condition"`
	}{
		Argzone:      zone,
		Argid:        id,
		Argcondition: condition,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] NFSAPI.MonitorInterface end")
	}()

	resultInterfaceActivity, err := t.Internal.MonitorInterface(ctx, zone, id, condition)
	targetResults := struct {
		InterfaceActivity *sacloud.InterfaceActivity
		Error             error
	}{
		InterfaceActivity: resultInterfaceActivity,
		Error:             err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultInterfaceActivity, err
}

/*************************************************
* NoteTracer
*************************************************/

// NoteTracer is for trace NoteOp operations
type NoteTracer struct {
	Internal sacloud.NoteAPI
}

// NewNoteTracer creates new NoteTracer instance
func NewNoteTracer(in sacloud.NoteAPI) sacloud.NoteAPI {
	return &NoteTracer{
		Internal: in,
	}
}

// Find is API call with trace log
func (t *NoteTracer) Find(ctx context.Context, conditions *sacloud.FindCondition) (*sacloud.NoteFindResult, error) {
	log.Println("[TRACE] NoteAPI.Find start")
	targetArguments := struct {
		Argconditions *sacloud.FindCondition `json:"conditions"`
	}{
		Argconditions: conditions,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] NoteAPI.Find end")
	}()

	result, err := t.Internal.Find(ctx, conditions)
	targetResults := struct {
		Result *sacloud.NoteFindResult
		Error  error
	}{
		Result: result,
		Error:  err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return result, err
}

// Create is API call with trace log
func (t *NoteTracer) Create(ctx context.Context, param *sacloud.NoteCreateRequest) (*sacloud.Note, error) {
	log.Println("[TRACE] NoteAPI.Create start")
	targetArguments := struct {
		Argparam *sacloud.NoteCreateRequest `json:"param"`
	}{
		Argparam: param,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] NoteAPI.Create end")
	}()

	resultNote, err := t.Internal.Create(ctx, param)
	targetResults := struct {
		Note  *sacloud.Note
		Error error
	}{
		Note:  resultNote,
		Error: err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultNote, err
}

// Read is API call with trace log
func (t *NoteTracer) Read(ctx context.Context, id types.ID) (*sacloud.Note, error) {
	log.Println("[TRACE] NoteAPI.Read start")
	targetArguments := struct {
		Argid types.ID `json:"id"`
	}{
		Argid: id,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] NoteAPI.Read end")
	}()

	resultNote, err := t.Internal.Read(ctx, id)
	targetResults := struct {
		Note  *sacloud.Note
		Error error
	}{
		Note:  resultNote,
		Error: err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultNote, err
}

// Update is API call with trace log
func (t *NoteTracer) Update(ctx context.Context, id types.ID, param *sacloud.NoteUpdateRequest) (*sacloud.Note, error) {
	log.Println("[TRACE] NoteAPI.Update start")
	targetArguments := struct {
		Argid    types.ID                   `json:"id"`
		Argparam *sacloud.NoteUpdateRequest `json:"param"`
	}{
		Argid:    id,
		Argparam: param,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] NoteAPI.Update end")
	}()

	resultNote, err := t.Internal.Update(ctx, id, param)
	targetResults := struct {
		Note  *sacloud.Note
		Error error
	}{
		Note:  resultNote,
		Error: err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultNote, err
}

// Delete is API call with trace log
func (t *NoteTracer) Delete(ctx context.Context, id types.ID) error {
	log.Println("[TRACE] NoteAPI.Delete start")
	targetArguments := struct {
		Argid types.ID `json:"id"`
	}{
		Argid: id,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] NoteAPI.Delete end")
	}()

	err := t.Internal.Delete(ctx, id)
	targetResults := struct {
		Error error
	}{
		Error: err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return err
}

/*************************************************
* PacketFilterTracer
*************************************************/

// PacketFilterTracer is for trace PacketFilterOp operations
type PacketFilterTracer struct {
	Internal sacloud.PacketFilterAPI
}

// NewPacketFilterTracer creates new PacketFilterTracer instance
func NewPacketFilterTracer(in sacloud.PacketFilterAPI) sacloud.PacketFilterAPI {
	return &PacketFilterTracer{
		Internal: in,
	}
}

// Find is API call with trace log
func (t *PacketFilterTracer) Find(ctx context.Context, zone string, conditions *sacloud.FindCondition) (*sacloud.PacketFilterFindResult, error) {
	log.Println("[TRACE] PacketFilterAPI.Find start")
	targetArguments := struct {
		Argzone       string
		Argconditions *sacloud.FindCondition `json:"conditions"`
	}{
		Argzone:       zone,
		Argconditions: conditions,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] PacketFilterAPI.Find end")
	}()

	result, err := t.Internal.Find(ctx, zone, conditions)
	targetResults := struct {
		Result *sacloud.PacketFilterFindResult
		Error  error
	}{
		Result: result,
		Error:  err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return result, err
}

// Create is API call with trace log
func (t *PacketFilterTracer) Create(ctx context.Context, zone string, param *sacloud.PacketFilterCreateRequest) (*sacloud.PacketFilter, error) {
	log.Println("[TRACE] PacketFilterAPI.Create start")
	targetArguments := struct {
		Argzone  string
		Argparam *sacloud.PacketFilterCreateRequest `json:"param"`
	}{
		Argzone:  zone,
		Argparam: param,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] PacketFilterAPI.Create end")
	}()

	resultPacketFilter, err := t.Internal.Create(ctx, zone, param)
	targetResults := struct {
		PacketFilter *sacloud.PacketFilter
		Error        error
	}{
		PacketFilter: resultPacketFilter,
		Error:        err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultPacketFilter, err
}

// Read is API call with trace log
func (t *PacketFilterTracer) Read(ctx context.Context, zone string, id types.ID) (*sacloud.PacketFilter, error) {
	log.Println("[TRACE] PacketFilterAPI.Read start")
	targetArguments := struct {
		Argzone string
		Argid   types.ID `json:"id"`
	}{
		Argzone: zone,
		Argid:   id,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] PacketFilterAPI.Read end")
	}()

	resultPacketFilter, err := t.Internal.Read(ctx, zone, id)
	targetResults := struct {
		PacketFilter *sacloud.PacketFilter
		Error        error
	}{
		PacketFilter: resultPacketFilter,
		Error:        err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultPacketFilter, err
}

// Update is API call with trace log
func (t *PacketFilterTracer) Update(ctx context.Context, zone string, id types.ID, updateParam *sacloud.PacketFilterUpdateRequest, originalExpressionHash string) (*sacloud.PacketFilter, error) {
	log.Println("[TRACE] PacketFilterAPI.Update start")
	targetArguments := struct {
		Argzone                   string
		Argid                     types.ID                           `json:"id"`
		ArgupdateParam            *sacloud.PacketFilterUpdateRequest `json:"updateParam"`
		ArgoriginalExpressionHash string                             `json:"originalExpressionHash"`
	}{
		Argzone:                   zone,
		Argid:                     id,
		ArgupdateParam:            updateParam,
		ArgoriginalExpressionHash: originalExpressionHash,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] PacketFilterAPI.Update end")
	}()

	resultPacketFilter, err := t.Internal.Update(ctx, zone, id, updateParam, originalExpressionHash)
	targetResults := struct {
		PacketFilter *sacloud.PacketFilter
		Error        error
	}{
		PacketFilter: resultPacketFilter,
		Error:        err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultPacketFilter, err
}

// Delete is API call with trace log
func (t *PacketFilterTracer) Delete(ctx context.Context, zone string, id types.ID) error {
	log.Println("[TRACE] PacketFilterAPI.Delete start")
	targetArguments := struct {
		Argzone string
		Argid   types.ID `json:"id"`
	}{
		Argzone: zone,
		Argid:   id,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] PacketFilterAPI.Delete end")
	}()

	err := t.Internal.Delete(ctx, zone, id)
	targetResults := struct {
		Error error
	}{
		Error: err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return err
}

/*************************************************
* PrivateHostTracer
*************************************************/

// PrivateHostTracer is for trace PrivateHostOp operations
type PrivateHostTracer struct {
	Internal sacloud.PrivateHostAPI
}

// NewPrivateHostTracer creates new PrivateHostTracer instance
func NewPrivateHostTracer(in sacloud.PrivateHostAPI) sacloud.PrivateHostAPI {
	return &PrivateHostTracer{
		Internal: in,
	}
}

// Find is API call with trace log
func (t *PrivateHostTracer) Find(ctx context.Context, zone string, conditions *sacloud.FindCondition) (*sacloud.PrivateHostFindResult, error) {
	log.Println("[TRACE] PrivateHostAPI.Find start")
	targetArguments := struct {
		Argzone       string
		Argconditions *sacloud.FindCondition `json:"conditions"`
	}{
		Argzone:       zone,
		Argconditions: conditions,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] PrivateHostAPI.Find end")
	}()

	result, err := t.Internal.Find(ctx, zone, conditions)
	targetResults := struct {
		Result *sacloud.PrivateHostFindResult
		Error  error
	}{
		Result: result,
		Error:  err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return result, err
}

// Create is API call with trace log
func (t *PrivateHostTracer) Create(ctx context.Context, zone string, param *sacloud.PrivateHostCreateRequest) (*sacloud.PrivateHost, error) {
	log.Println("[TRACE] PrivateHostAPI.Create start")
	targetArguments := struct {
		Argzone  string
		Argparam *sacloud.PrivateHostCreateRequest `json:"param"`
	}{
		Argzone:  zone,
		Argparam: param,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] PrivateHostAPI.Create end")
	}()

	resultPrivateHost, err := t.Internal.Create(ctx, zone, param)
	targetResults := struct {
		PrivateHost *sacloud.PrivateHost
		Error       error
	}{
		PrivateHost: resultPrivateHost,
		Error:       err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultPrivateHost, err
}

// Read is API call with trace log
func (t *PrivateHostTracer) Read(ctx context.Context, zone string, id types.ID) (*sacloud.PrivateHost, error) {
	log.Println("[TRACE] PrivateHostAPI.Read start")
	targetArguments := struct {
		Argzone string
		Argid   types.ID `json:"id"`
	}{
		Argzone: zone,
		Argid:   id,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] PrivateHostAPI.Read end")
	}()

	resultPrivateHost, err := t.Internal.Read(ctx, zone, id)
	targetResults := struct {
		PrivateHost *sacloud.PrivateHost
		Error       error
	}{
		PrivateHost: resultPrivateHost,
		Error:       err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultPrivateHost, err
}

// Update is API call with trace log
func (t *PrivateHostTracer) Update(ctx context.Context, zone string, id types.ID, param *sacloud.PrivateHostUpdateRequest) (*sacloud.PrivateHost, error) {
	log.Println("[TRACE] PrivateHostAPI.Update start")
	targetArguments := struct {
		Argzone  string
		Argid    types.ID                          `json:"id"`
		Argparam *sacloud.PrivateHostUpdateRequest `json:"param"`
	}{
		Argzone:  zone,
		Argid:    id,
		Argparam: param,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] PrivateHostAPI.Update end")
	}()

	resultPrivateHost, err := t.Internal.Update(ctx, zone, id, param)
	targetResults := struct {
		PrivateHost *sacloud.PrivateHost
		Error       error
	}{
		PrivateHost: resultPrivateHost,
		Error:       err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultPrivateHost, err
}

// Delete is API call with trace log
func (t *PrivateHostTracer) Delete(ctx context.Context, zone string, id types.ID) error {
	log.Println("[TRACE] PrivateHostAPI.Delete start")
	targetArguments := struct {
		Argzone string
		Argid   types.ID `json:"id"`
	}{
		Argzone: zone,
		Argid:   id,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] PrivateHostAPI.Delete end")
	}()

	err := t.Internal.Delete(ctx, zone, id)
	targetResults := struct {
		Error error
	}{
		Error: err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return err
}

/*************************************************
* PrivateHostPlanTracer
*************************************************/

// PrivateHostPlanTracer is for trace PrivateHostPlanOp operations
type PrivateHostPlanTracer struct {
	Internal sacloud.PrivateHostPlanAPI
}

// NewPrivateHostPlanTracer creates new PrivateHostPlanTracer instance
func NewPrivateHostPlanTracer(in sacloud.PrivateHostPlanAPI) sacloud.PrivateHostPlanAPI {
	return &PrivateHostPlanTracer{
		Internal: in,
	}
}

// Find is API call with trace log
func (t *PrivateHostPlanTracer) Find(ctx context.Context, zone string, conditions *sacloud.FindCondition) (*sacloud.PrivateHostPlanFindResult, error) {
	log.Println("[TRACE] PrivateHostPlanAPI.Find start")
	targetArguments := struct {
		Argzone       string
		Argconditions *sacloud.FindCondition `json:"conditions"`
	}{
		Argzone:       zone,
		Argconditions: conditions,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] PrivateHostPlanAPI.Find end")
	}()

	result, err := t.Internal.Find(ctx, zone, conditions)
	targetResults := struct {
		Result *sacloud.PrivateHostPlanFindResult
		Error  error
	}{
		Result: result,
		Error:  err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return result, err
}

// Read is API call with trace log
func (t *PrivateHostPlanTracer) Read(ctx context.Context, zone string, id types.ID) (*sacloud.PrivateHostPlan, error) {
	log.Println("[TRACE] PrivateHostPlanAPI.Read start")
	targetArguments := struct {
		Argzone string
		Argid   types.ID `json:"id"`
	}{
		Argzone: zone,
		Argid:   id,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] PrivateHostPlanAPI.Read end")
	}()

	resultPrivateHostPlan, err := t.Internal.Read(ctx, zone, id)
	targetResults := struct {
		PrivateHostPlan *sacloud.PrivateHostPlan
		Error           error
	}{
		PrivateHostPlan: resultPrivateHostPlan,
		Error:           err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultPrivateHostPlan, err
}

/*************************************************
* ProxyLBTracer
*************************************************/

// ProxyLBTracer is for trace ProxyLBOp operations
type ProxyLBTracer struct {
	Internal sacloud.ProxyLBAPI
}

// NewProxyLBTracer creates new ProxyLBTracer instance
func NewProxyLBTracer(in sacloud.ProxyLBAPI) sacloud.ProxyLBAPI {
	return &ProxyLBTracer{
		Internal: in,
	}
}

// Find is API call with trace log
func (t *ProxyLBTracer) Find(ctx context.Context, conditions *sacloud.FindCondition) (*sacloud.ProxyLBFindResult, error) {
	log.Println("[TRACE] ProxyLBAPI.Find start")
	targetArguments := struct {
		Argconditions *sacloud.FindCondition `json:"conditions"`
	}{
		Argconditions: conditions,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] ProxyLBAPI.Find end")
	}()

	result, err := t.Internal.Find(ctx, conditions)
	targetResults := struct {
		Result *sacloud.ProxyLBFindResult
		Error  error
	}{
		Result: result,
		Error:  err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return result, err
}

// Create is API call with trace log
func (t *ProxyLBTracer) Create(ctx context.Context, param *sacloud.ProxyLBCreateRequest) (*sacloud.ProxyLB, error) {
	log.Println("[TRACE] ProxyLBAPI.Create start")
	targetArguments := struct {
		Argparam *sacloud.ProxyLBCreateRequest `json:"param"`
	}{
		Argparam: param,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] ProxyLBAPI.Create end")
	}()

	resultProxyLB, err := t.Internal.Create(ctx, param)
	targetResults := struct {
		ProxyLB *sacloud.ProxyLB
		Error   error
	}{
		ProxyLB: resultProxyLB,
		Error:   err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultProxyLB, err
}

// Read is API call with trace log
func (t *ProxyLBTracer) Read(ctx context.Context, id types.ID) (*sacloud.ProxyLB, error) {
	log.Println("[TRACE] ProxyLBAPI.Read start")
	targetArguments := struct {
		Argid types.ID `json:"id"`
	}{
		Argid: id,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] ProxyLBAPI.Read end")
	}()

	resultProxyLB, err := t.Internal.Read(ctx, id)
	targetResults := struct {
		ProxyLB *sacloud.ProxyLB
		Error   error
	}{
		ProxyLB: resultProxyLB,
		Error:   err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultProxyLB, err
}

// Update is API call with trace log
func (t *ProxyLBTracer) Update(ctx context.Context, id types.ID, param *sacloud.ProxyLBUpdateRequest) (*sacloud.ProxyLB, error) {
	log.Println("[TRACE] ProxyLBAPI.Update start")
	targetArguments := struct {
		Argid    types.ID                      `json:"id"`
		Argparam *sacloud.ProxyLBUpdateRequest `json:"param"`
	}{
		Argid:    id,
		Argparam: param,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] ProxyLBAPI.Update end")
	}()

	resultProxyLB, err := t.Internal.Update(ctx, id, param)
	targetResults := struct {
		ProxyLB *sacloud.ProxyLB
		Error   error
	}{
		ProxyLB: resultProxyLB,
		Error:   err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultProxyLB, err
}

// UpdateSettings is API call with trace log
func (t *ProxyLBTracer) UpdateSettings(ctx context.Context, id types.ID, param *sacloud.ProxyLBUpdateSettingsRequest) (*sacloud.ProxyLB, error) {
	log.Println("[TRACE] ProxyLBAPI.UpdateSettings start")
	targetArguments := struct {
		Argid    types.ID                              `json:"id"`
		Argparam *sacloud.ProxyLBUpdateSettingsRequest `json:"param"`
	}{
		Argid:    id,
		Argparam: param,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] ProxyLBAPI.UpdateSettings end")
	}()

	resultProxyLB, err := t.Internal.UpdateSettings(ctx, id, param)
	targetResults := struct {
		ProxyLB *sacloud.ProxyLB
		Error   error
	}{
		ProxyLB: resultProxyLB,
		Error:   err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultProxyLB, err
}

// Delete is API call with trace log
func (t *ProxyLBTracer) Delete(ctx context.Context, id types.ID) error {
	log.Println("[TRACE] ProxyLBAPI.Delete start")
	targetArguments := struct {
		Argid types.ID `json:"id"`
	}{
		Argid: id,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] ProxyLBAPI.Delete end")
	}()

	err := t.Internal.Delete(ctx, id)
	targetResults := struct {
		Error error
	}{
		Error: err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return err
}

// ChangePlan is API call with trace log
func (t *ProxyLBTracer) ChangePlan(ctx context.Context, id types.ID, param *sacloud.ProxyLBChangePlanRequest) (*sacloud.ProxyLB, error) {
	log.Println("[TRACE] ProxyLBAPI.ChangePlan start")
	targetArguments := struct {
		Argid    types.ID                          `json:"id"`
		Argparam *sacloud.ProxyLBChangePlanRequest `json:"param"`
	}{
		Argid:    id,
		Argparam: param,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] ProxyLBAPI.ChangePlan end")
	}()

	resultProxyLB, err := t.Internal.ChangePlan(ctx, id, param)
	targetResults := struct {
		ProxyLB *sacloud.ProxyLB
		Error   error
	}{
		ProxyLB: resultProxyLB,
		Error:   err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultProxyLB, err
}

// GetCertificates is API call with trace log
func (t *ProxyLBTracer) GetCertificates(ctx context.Context, id types.ID) (*sacloud.ProxyLBCertificates, error) {
	log.Println("[TRACE] ProxyLBAPI.GetCertificates start")
	targetArguments := struct {
		Argid types.ID `json:"id"`
	}{
		Argid: id,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] ProxyLBAPI.GetCertificates end")
	}()

	resultProxyLBCertificates, err := t.Internal.GetCertificates(ctx, id)
	targetResults := struct {
		ProxyLBCertificates *sacloud.ProxyLBCertificates
		Error               error
	}{
		ProxyLBCertificates: resultProxyLBCertificates,
		Error:               err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultProxyLBCertificates, err
}

// SetCertificates is API call with trace log
func (t *ProxyLBTracer) SetCertificates(ctx context.Context, id types.ID, param *sacloud.ProxyLBSetCertificatesRequest) (*sacloud.ProxyLBCertificates, error) {
	log.Println("[TRACE] ProxyLBAPI.SetCertificates start")
	targetArguments := struct {
		Argid    types.ID                               `json:"id"`
		Argparam *sacloud.ProxyLBSetCertificatesRequest `json:"param"`
	}{
		Argid:    id,
		Argparam: param,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] ProxyLBAPI.SetCertificates end")
	}()

	resultProxyLBCertificates, err := t.Internal.SetCertificates(ctx, id, param)
	targetResults := struct {
		ProxyLBCertificates *sacloud.ProxyLBCertificates
		Error               error
	}{
		ProxyLBCertificates: resultProxyLBCertificates,
		Error:               err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultProxyLBCertificates, err
}

// DeleteCertificates is API call with trace log
func (t *ProxyLBTracer) DeleteCertificates(ctx context.Context, id types.ID) error {
	log.Println("[TRACE] ProxyLBAPI.DeleteCertificates start")
	targetArguments := struct {
		Argid types.ID `json:"id"`
	}{
		Argid: id,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] ProxyLBAPI.DeleteCertificates end")
	}()

	err := t.Internal.DeleteCertificates(ctx, id)
	targetResults := struct {
		Error error
	}{
		Error: err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return err
}

// RenewLetsEncryptCert is API call with trace log
func (t *ProxyLBTracer) RenewLetsEncryptCert(ctx context.Context, id types.ID) error {
	log.Println("[TRACE] ProxyLBAPI.RenewLetsEncryptCert start")
	targetArguments := struct {
		Argid types.ID `json:"id"`
	}{
		Argid: id,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] ProxyLBAPI.RenewLetsEncryptCert end")
	}()

	err := t.Internal.RenewLetsEncryptCert(ctx, id)
	targetResults := struct {
		Error error
	}{
		Error: err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return err
}

// HealthStatus is API call with trace log
func (t *ProxyLBTracer) HealthStatus(ctx context.Context, id types.ID) (*sacloud.ProxyLBHealth, error) {
	log.Println("[TRACE] ProxyLBAPI.HealthStatus start")
	targetArguments := struct {
		Argid types.ID `json:"id"`
	}{
		Argid: id,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] ProxyLBAPI.HealthStatus end")
	}()

	resultProxyLBHealth, err := t.Internal.HealthStatus(ctx, id)
	targetResults := struct {
		ProxyLBHealth *sacloud.ProxyLBHealth
		Error         error
	}{
		ProxyLBHealth: resultProxyLBHealth,
		Error:         err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultProxyLBHealth, err
}

// MonitorConnection is API call with trace log
func (t *ProxyLBTracer) MonitorConnection(ctx context.Context, id types.ID, condition *sacloud.MonitorCondition) (*sacloud.ConnectionActivity, error) {
	log.Println("[TRACE] ProxyLBAPI.MonitorConnection start")
	targetArguments := struct {
		Argid        types.ID                  `json:"id"`
		Argcondition *sacloud.MonitorCondition `json:"condition"`
	}{
		Argid:        id,
		Argcondition: condition,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] ProxyLBAPI.MonitorConnection end")
	}()

	resultConnectionActivity, err := t.Internal.MonitorConnection(ctx, id, condition)
	targetResults := struct {
		ConnectionActivity *sacloud.ConnectionActivity
		Error              error
	}{
		ConnectionActivity: resultConnectionActivity,
		Error:              err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultConnectionActivity, err
}

/*************************************************
* RegionTracer
*************************************************/

// RegionTracer is for trace RegionOp operations
type RegionTracer struct {
	Internal sacloud.RegionAPI
}

// NewRegionTracer creates new RegionTracer instance
func NewRegionTracer(in sacloud.RegionAPI) sacloud.RegionAPI {
	return &RegionTracer{
		Internal: in,
	}
}

// Find is API call with trace log
func (t *RegionTracer) Find(ctx context.Context, conditions *sacloud.FindCondition) (*sacloud.RegionFindResult, error) {
	log.Println("[TRACE] RegionAPI.Find start")
	targetArguments := struct {
		Argconditions *sacloud.FindCondition `json:"conditions"`
	}{
		Argconditions: conditions,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] RegionAPI.Find end")
	}()

	result, err := t.Internal.Find(ctx, conditions)
	targetResults := struct {
		Result *sacloud.RegionFindResult
		Error  error
	}{
		Result: result,
		Error:  err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return result, err
}

// Read is API call with trace log
func (t *RegionTracer) Read(ctx context.Context, id types.ID) (*sacloud.Region, error) {
	log.Println("[TRACE] RegionAPI.Read start")
	targetArguments := struct {
		Argid types.ID `json:"id"`
	}{
		Argid: id,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] RegionAPI.Read end")
	}()

	resultRegion, err := t.Internal.Read(ctx, id)
	targetResults := struct {
		Region *sacloud.Region
		Error  error
	}{
		Region: resultRegion,
		Error:  err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultRegion, err
}

/*************************************************
* ServerTracer
*************************************************/

// ServerTracer is for trace ServerOp operations
type ServerTracer struct {
	Internal sacloud.ServerAPI
}

// NewServerTracer creates new ServerTracer instance
func NewServerTracer(in sacloud.ServerAPI) sacloud.ServerAPI {
	return &ServerTracer{
		Internal: in,
	}
}

// Find is API call with trace log
func (t *ServerTracer) Find(ctx context.Context, zone string, conditions *sacloud.FindCondition) (*sacloud.ServerFindResult, error) {
	log.Println("[TRACE] ServerAPI.Find start")
	targetArguments := struct {
		Argzone       string
		Argconditions *sacloud.FindCondition `json:"conditions"`
	}{
		Argzone:       zone,
		Argconditions: conditions,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] ServerAPI.Find end")
	}()

	result, err := t.Internal.Find(ctx, zone, conditions)
	targetResults := struct {
		Result *sacloud.ServerFindResult
		Error  error
	}{
		Result: result,
		Error:  err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return result, err
}

// Create is API call with trace log
func (t *ServerTracer) Create(ctx context.Context, zone string, param *sacloud.ServerCreateRequest) (*sacloud.Server, error) {
	log.Println("[TRACE] ServerAPI.Create start")
	targetArguments := struct {
		Argzone  string
		Argparam *sacloud.ServerCreateRequest `json:"param"`
	}{
		Argzone:  zone,
		Argparam: param,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] ServerAPI.Create end")
	}()

	resultServer, err := t.Internal.Create(ctx, zone, param)
	targetResults := struct {
		Server *sacloud.Server
		Error  error
	}{
		Server: resultServer,
		Error:  err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultServer, err
}

// Read is API call with trace log
func (t *ServerTracer) Read(ctx context.Context, zone string, id types.ID) (*sacloud.Server, error) {
	log.Println("[TRACE] ServerAPI.Read start")
	targetArguments := struct {
		Argzone string
		Argid   types.ID `json:"id"`
	}{
		Argzone: zone,
		Argid:   id,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] ServerAPI.Read end")
	}()

	resultServer, err := t.Internal.Read(ctx, zone, id)
	targetResults := struct {
		Server *sacloud.Server
		Error  error
	}{
		Server: resultServer,
		Error:  err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultServer, err
}

// Update is API call with trace log
func (t *ServerTracer) Update(ctx context.Context, zone string, id types.ID, param *sacloud.ServerUpdateRequest) (*sacloud.Server, error) {
	log.Println("[TRACE] ServerAPI.Update start")
	targetArguments := struct {
		Argzone  string
		Argid    types.ID                     `json:"id"`
		Argparam *sacloud.ServerUpdateRequest `json:"param"`
	}{
		Argzone:  zone,
		Argid:    id,
		Argparam: param,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] ServerAPI.Update end")
	}()

	resultServer, err := t.Internal.Update(ctx, zone, id, param)
	targetResults := struct {
		Server *sacloud.Server
		Error  error
	}{
		Server: resultServer,
		Error:  err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultServer, err
}

// Delete is API call with trace log
func (t *ServerTracer) Delete(ctx context.Context, zone string, id types.ID) error {
	log.Println("[TRACE] ServerAPI.Delete start")
	targetArguments := struct {
		Argzone string
		Argid   types.ID `json:"id"`
	}{
		Argzone: zone,
		Argid:   id,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] ServerAPI.Delete end")
	}()

	err := t.Internal.Delete(ctx, zone, id)
	targetResults := struct {
		Error error
	}{
		Error: err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return err
}

// DeleteWithDisks is API call with trace log
func (t *ServerTracer) DeleteWithDisks(ctx context.Context, zone string, id types.ID, disks *sacloud.ServerDeleteWithDisksRequest) error {
	log.Println("[TRACE] ServerAPI.DeleteWithDisks start")
	targetArguments := struct {
		Argzone  string
		Argid    types.ID                              `json:"id"`
		Argdisks *sacloud.ServerDeleteWithDisksRequest `json:"disks"`
	}{
		Argzone:  zone,
		Argid:    id,
		Argdisks: disks,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] ServerAPI.DeleteWithDisks end")
	}()

	err := t.Internal.DeleteWithDisks(ctx, zone, id, disks)
	targetResults := struct {
		Error error
	}{
		Error: err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return err
}

// ChangePlan is API call with trace log
func (t *ServerTracer) ChangePlan(ctx context.Context, zone string, id types.ID, plan *sacloud.ServerChangePlanRequest) (*sacloud.Server, error) {
	log.Println("[TRACE] ServerAPI.ChangePlan start")
	targetArguments := struct {
		Argzone string
		Argid   types.ID                         `json:"id"`
		Argplan *sacloud.ServerChangePlanRequest `json:"plan"`
	}{
		Argzone: zone,
		Argid:   id,
		Argplan: plan,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] ServerAPI.ChangePlan end")
	}()

	resultServer, err := t.Internal.ChangePlan(ctx, zone, id, plan)
	targetResults := struct {
		Server *sacloud.Server
		Error  error
	}{
		Server: resultServer,
		Error:  err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultServer, err
}

// InsertCDROM is API call with trace log
func (t *ServerTracer) InsertCDROM(ctx context.Context, zone string, id types.ID, insertParam *sacloud.InsertCDROMRequest) error {
	log.Println("[TRACE] ServerAPI.InsertCDROM start")
	targetArguments := struct {
		Argzone        string
		Argid          types.ID                    `json:"id"`
		ArginsertParam *sacloud.InsertCDROMRequest `json:"insertParam"`
	}{
		Argzone:        zone,
		Argid:          id,
		ArginsertParam: insertParam,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] ServerAPI.InsertCDROM end")
	}()

	err := t.Internal.InsertCDROM(ctx, zone, id, insertParam)
	targetResults := struct {
		Error error
	}{
		Error: err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return err
}

// EjectCDROM is API call with trace log
func (t *ServerTracer) EjectCDROM(ctx context.Context, zone string, id types.ID, ejectParam *sacloud.EjectCDROMRequest) error {
	log.Println("[TRACE] ServerAPI.EjectCDROM start")
	targetArguments := struct {
		Argzone       string
		Argid         types.ID                   `json:"id"`
		ArgejectParam *sacloud.EjectCDROMRequest `json:"ejectParam"`
	}{
		Argzone:       zone,
		Argid:         id,
		ArgejectParam: ejectParam,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] ServerAPI.EjectCDROM end")
	}()

	err := t.Internal.EjectCDROM(ctx, zone, id, ejectParam)
	targetResults := struct {
		Error error
	}{
		Error: err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return err
}

// Boot is API call with trace log
func (t *ServerTracer) Boot(ctx context.Context, zone string, id types.ID) error {
	log.Println("[TRACE] ServerAPI.Boot start")
	targetArguments := struct {
		Argzone string
		Argid   types.ID `json:"id"`
	}{
		Argzone: zone,
		Argid:   id,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] ServerAPI.Boot end")
	}()

	err := t.Internal.Boot(ctx, zone, id)
	targetResults := struct {
		Error error
	}{
		Error: err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return err
}

// Shutdown is API call with trace log
func (t *ServerTracer) Shutdown(ctx context.Context, zone string, id types.ID, shutdownOption *sacloud.ShutdownOption) error {
	log.Println("[TRACE] ServerAPI.Shutdown start")
	targetArguments := struct {
		Argzone           string
		Argid             types.ID                `json:"id"`
		ArgshutdownOption *sacloud.ShutdownOption `json:"shutdownOption"`
	}{
		Argzone:           zone,
		Argid:             id,
		ArgshutdownOption: shutdownOption,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] ServerAPI.Shutdown end")
	}()

	err := t.Internal.Shutdown(ctx, zone, id, shutdownOption)
	targetResults := struct {
		Error error
	}{
		Error: err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return err
}

// Reset is API call with trace log
func (t *ServerTracer) Reset(ctx context.Context, zone string, id types.ID) error {
	log.Println("[TRACE] ServerAPI.Reset start")
	targetArguments := struct {
		Argzone string
		Argid   types.ID `json:"id"`
	}{
		Argzone: zone,
		Argid:   id,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] ServerAPI.Reset end")
	}()

	err := t.Internal.Reset(ctx, zone, id)
	targetResults := struct {
		Error error
	}{
		Error: err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return err
}

// BootWithVariables is API call with trace log
func (t *ServerTracer) BootWithVariables(ctx context.Context, zone string, id types.ID, param *sacloud.ServerBootVariables) error {
	log.Println("[TRACE] ServerAPI.BootWithVariables start")
	targetArguments := struct {
		Argzone  string
		Argid    types.ID                     `json:"id"`
		Argparam *sacloud.ServerBootVariables `json:"param"`
	}{
		Argzone:  zone,
		Argid:    id,
		Argparam: param,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] ServerAPI.BootWithVariables end")
	}()

	err := t.Internal.BootWithVariables(ctx, zone, id, param)
	targetResults := struct {
		Error error
	}{
		Error: err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return err
}

// SendKey is API call with trace log
func (t *ServerTracer) SendKey(ctx context.Context, zone string, id types.ID, keyboardParam *sacloud.SendKeyRequest) error {
	log.Println("[TRACE] ServerAPI.SendKey start")
	targetArguments := struct {
		Argzone          string
		Argid            types.ID                `json:"id"`
		ArgkeyboardParam *sacloud.SendKeyRequest `json:"keyboardParam"`
	}{
		Argzone:          zone,
		Argid:            id,
		ArgkeyboardParam: keyboardParam,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] ServerAPI.SendKey end")
	}()

	err := t.Internal.SendKey(ctx, zone, id, keyboardParam)
	targetResults := struct {
		Error error
	}{
		Error: err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return err
}

// SendNMI is API call with trace log
func (t *ServerTracer) SendNMI(ctx context.Context, zone string, id types.ID) error {
	log.Println("[TRACE] ServerAPI.SendNMI start")
	targetArguments := struct {
		Argzone string
		Argid   types.ID `json:"id"`
	}{
		Argzone: zone,
		Argid:   id,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] ServerAPI.SendNMI end")
	}()

	err := t.Internal.SendNMI(ctx, zone, id)
	targetResults := struct {
		Error error
	}{
		Error: err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return err
}

// GetVNCProxy is API call with trace log
func (t *ServerTracer) GetVNCProxy(ctx context.Context, zone string, id types.ID) (*sacloud.VNCProxyInfo, error) {
	log.Println("[TRACE] ServerAPI.GetVNCProxy start")
	targetArguments := struct {
		Argzone string
		Argid   types.ID `json:"id"`
	}{
		Argzone: zone,
		Argid:   id,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] ServerAPI.GetVNCProxy end")
	}()

	resultVNCProxyInfo, err := t.Internal.GetVNCProxy(ctx, zone, id)
	targetResults := struct {
		VNCProxyInfo *sacloud.VNCProxyInfo
		Error        error
	}{
		VNCProxyInfo: resultVNCProxyInfo,
		Error:        err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultVNCProxyInfo, err
}

// Monitor is API call with trace log
func (t *ServerTracer) Monitor(ctx context.Context, zone string, id types.ID, condition *sacloud.MonitorCondition) (*sacloud.CPUTimeActivity, error) {
	log.Println("[TRACE] ServerAPI.Monitor start")
	targetArguments := struct {
		Argzone      string
		Argid        types.ID                  `json:"id"`
		Argcondition *sacloud.MonitorCondition `json:"condition"`
	}{
		Argzone:      zone,
		Argid:        id,
		Argcondition: condition,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] ServerAPI.Monitor end")
	}()

	resultCPUTimeActivity, err := t.Internal.Monitor(ctx, zone, id, condition)
	targetResults := struct {
		CPUTimeActivity *sacloud.CPUTimeActivity
		Error           error
	}{
		CPUTimeActivity: resultCPUTimeActivity,
		Error:           err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultCPUTimeActivity, err
}

// MonitorCPU is API call with trace log
func (t *ServerTracer) MonitorCPU(ctx context.Context, zone string, id types.ID, condition *sacloud.MonitorCondition) (*sacloud.CPUTimeActivity, error) {
	log.Println("[TRACE] ServerAPI.MonitorCPU start")
	targetArguments := struct {
		Argzone      string
		Argid        types.ID                  `json:"id"`
		Argcondition *sacloud.MonitorCondition `json:"condition"`
	}{
		Argzone:      zone,
		Argid:        id,
		Argcondition: condition,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] ServerAPI.MonitorCPU end")
	}()

	resultCPUTimeActivity, err := t.Internal.MonitorCPU(ctx, zone, id, condition)
	targetResults := struct {
		CPUTimeActivity *sacloud.CPUTimeActivity
		Error           error
	}{
		CPUTimeActivity: resultCPUTimeActivity,
		Error:           err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultCPUTimeActivity, err
}

/*************************************************
* ServerPlanTracer
*************************************************/

// ServerPlanTracer is for trace ServerPlanOp operations
type ServerPlanTracer struct {
	Internal sacloud.ServerPlanAPI
}

// NewServerPlanTracer creates new ServerPlanTracer instance
func NewServerPlanTracer(in sacloud.ServerPlanAPI) sacloud.ServerPlanAPI {
	return &ServerPlanTracer{
		Internal: in,
	}
}

// Find is API call with trace log
func (t *ServerPlanTracer) Find(ctx context.Context, zone string, conditions *sacloud.FindCondition) (*sacloud.ServerPlanFindResult, error) {
	log.Println("[TRACE] ServerPlanAPI.Find start")
	targetArguments := struct {
		Argzone       string
		Argconditions *sacloud.FindCondition `json:"conditions"`
	}{
		Argzone:       zone,
		Argconditions: conditions,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] ServerPlanAPI.Find end")
	}()

	result, err := t.Internal.Find(ctx, zone, conditions)
	targetResults := struct {
		Result *sacloud.ServerPlanFindResult
		Error  error
	}{
		Result: result,
		Error:  err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return result, err
}

// Read is API call with trace log
func (t *ServerPlanTracer) Read(ctx context.Context, zone string, id types.ID) (*sacloud.ServerPlan, error) {
	log.Println("[TRACE] ServerPlanAPI.Read start")
	targetArguments := struct {
		Argzone string
		Argid   types.ID `json:"id"`
	}{
		Argzone: zone,
		Argid:   id,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] ServerPlanAPI.Read end")
	}()

	resultServerPlan, err := t.Internal.Read(ctx, zone, id)
	targetResults := struct {
		ServerPlan *sacloud.ServerPlan
		Error      error
	}{
		ServerPlan: resultServerPlan,
		Error:      err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultServerPlan, err
}

/*************************************************
* ServiceClassTracer
*************************************************/

// ServiceClassTracer is for trace ServiceClassOp operations
type ServiceClassTracer struct {
	Internal sacloud.ServiceClassAPI
}

// NewServiceClassTracer creates new ServiceClassTracer instance
func NewServiceClassTracer(in sacloud.ServiceClassAPI) sacloud.ServiceClassAPI {
	return &ServiceClassTracer{
		Internal: in,
	}
}

// Find is API call with trace log
func (t *ServiceClassTracer) Find(ctx context.Context, zone string, conditions *sacloud.FindCondition) (*sacloud.ServiceClassFindResult, error) {
	log.Println("[TRACE] ServiceClassAPI.Find start")
	targetArguments := struct {
		Argzone       string
		Argconditions *sacloud.FindCondition `json:"conditions"`
	}{
		Argzone:       zone,
		Argconditions: conditions,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] ServiceClassAPI.Find end")
	}()

	result, err := t.Internal.Find(ctx, zone, conditions)
	targetResults := struct {
		Result *sacloud.ServiceClassFindResult
		Error  error
	}{
		Result: result,
		Error:  err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return result, err
}

/*************************************************
* SIMTracer
*************************************************/

// SIMTracer is for trace SIMOp operations
type SIMTracer struct {
	Internal sacloud.SIMAPI
}

// NewSIMTracer creates new SIMTracer instance
func NewSIMTracer(in sacloud.SIMAPI) sacloud.SIMAPI {
	return &SIMTracer{
		Internal: in,
	}
}

// Find is API call with trace log
func (t *SIMTracer) Find(ctx context.Context, conditions *sacloud.FindCondition) (*sacloud.SIMFindResult, error) {
	log.Println("[TRACE] SIMAPI.Find start")
	targetArguments := struct {
		Argconditions *sacloud.FindCondition `json:"conditions"`
	}{
		Argconditions: conditions,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] SIMAPI.Find end")
	}()

	result, err := t.Internal.Find(ctx, conditions)
	targetResults := struct {
		Result *sacloud.SIMFindResult
		Error  error
	}{
		Result: result,
		Error:  err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return result, err
}

// Create is API call with trace log
func (t *SIMTracer) Create(ctx context.Context, param *sacloud.SIMCreateRequest) (*sacloud.SIM, error) {
	log.Println("[TRACE] SIMAPI.Create start")
	targetArguments := struct {
		Argparam *sacloud.SIMCreateRequest `json:"param"`
	}{
		Argparam: param,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] SIMAPI.Create end")
	}()

	resultSIM, err := t.Internal.Create(ctx, param)
	targetResults := struct {
		SIM   *sacloud.SIM
		Error error
	}{
		SIM:   resultSIM,
		Error: err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultSIM, err
}

// Read is API call with trace log
func (t *SIMTracer) Read(ctx context.Context, id types.ID) (*sacloud.SIM, error) {
	log.Println("[TRACE] SIMAPI.Read start")
	targetArguments := struct {
		Argid types.ID `json:"id"`
	}{
		Argid: id,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] SIMAPI.Read end")
	}()

	resultSIM, err := t.Internal.Read(ctx, id)
	targetResults := struct {
		SIM   *sacloud.SIM
		Error error
	}{
		SIM:   resultSIM,
		Error: err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultSIM, err
}

// Update is API call with trace log
func (t *SIMTracer) Update(ctx context.Context, id types.ID, param *sacloud.SIMUpdateRequest) (*sacloud.SIM, error) {
	log.Println("[TRACE] SIMAPI.Update start")
	targetArguments := struct {
		Argid    types.ID                  `json:"id"`
		Argparam *sacloud.SIMUpdateRequest `json:"param"`
	}{
		Argid:    id,
		Argparam: param,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] SIMAPI.Update end")
	}()

	resultSIM, err := t.Internal.Update(ctx, id, param)
	targetResults := struct {
		SIM   *sacloud.SIM
		Error error
	}{
		SIM:   resultSIM,
		Error: err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultSIM, err
}

// Delete is API call with trace log
func (t *SIMTracer) Delete(ctx context.Context, id types.ID) error {
	log.Println("[TRACE] SIMAPI.Delete start")
	targetArguments := struct {
		Argid types.ID `json:"id"`
	}{
		Argid: id,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] SIMAPI.Delete end")
	}()

	err := t.Internal.Delete(ctx, id)
	targetResults := struct {
		Error error
	}{
		Error: err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return err
}

// Activate is API call with trace log
func (t *SIMTracer) Activate(ctx context.Context, id types.ID) error {
	log.Println("[TRACE] SIMAPI.Activate start")
	targetArguments := struct {
		Argid types.ID `json:"id"`
	}{
		Argid: id,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] SIMAPI.Activate end")
	}()

	err := t.Internal.Activate(ctx, id)
	targetResults := struct {
		Error error
	}{
		Error: err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return err
}

// Deactivate is API call with trace log
func (t *SIMTracer) Deactivate(ctx context.Context, id types.ID) error {
	log.Println("[TRACE] SIMAPI.Deactivate start")
	targetArguments := struct {
		Argid types.ID `json:"id"`
	}{
		Argid: id,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] SIMAPI.Deactivate end")
	}()

	err := t.Internal.Deactivate(ctx, id)
	targetResults := struct {
		Error error
	}{
		Error: err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return err
}

// AssignIP is API call with trace log
func (t *SIMTracer) AssignIP(ctx context.Context, id types.ID, param *sacloud.SIMAssignIPRequest) error {
	log.Println("[TRACE] SIMAPI.AssignIP start")
	targetArguments := struct {
		Argid    types.ID                    `json:"id"`
		Argparam *sacloud.SIMAssignIPRequest `json:"param"`
	}{
		Argid:    id,
		Argparam: param,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] SIMAPI.AssignIP end")
	}()

	err := t.Internal.AssignIP(ctx, id, param)
	targetResults := struct {
		Error error
	}{
		Error: err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return err
}

// ClearIP is API call with trace log
func (t *SIMTracer) ClearIP(ctx context.Context, id types.ID) error {
	log.Println("[TRACE] SIMAPI.ClearIP start")
	targetArguments := struct {
		Argid types.ID `json:"id"`
	}{
		Argid: id,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] SIMAPI.ClearIP end")
	}()

	err := t.Internal.ClearIP(ctx, id)
	targetResults := struct {
		Error error
	}{
		Error: err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return err
}

// IMEILock is API call with trace log
func (t *SIMTracer) IMEILock(ctx context.Context, id types.ID, param *sacloud.SIMIMEILockRequest) error {
	log.Println("[TRACE] SIMAPI.IMEILock start")
	targetArguments := struct {
		Argid    types.ID                    `json:"id"`
		Argparam *sacloud.SIMIMEILockRequest `json:"param"`
	}{
		Argid:    id,
		Argparam: param,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] SIMAPI.IMEILock end")
	}()

	err := t.Internal.IMEILock(ctx, id, param)
	targetResults := struct {
		Error error
	}{
		Error: err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return err
}

// IMEIUnlock is API call with trace log
func (t *SIMTracer) IMEIUnlock(ctx context.Context, id types.ID) error {
	log.Println("[TRACE] SIMAPI.IMEIUnlock start")
	targetArguments := struct {
		Argid types.ID `json:"id"`
	}{
		Argid: id,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] SIMAPI.IMEIUnlock end")
	}()

	err := t.Internal.IMEIUnlock(ctx, id)
	targetResults := struct {
		Error error
	}{
		Error: err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return err
}

// Logs is API call with trace log
func (t *SIMTracer) Logs(ctx context.Context, id types.ID) (*sacloud.SIMLogsResult, error) {
	log.Println("[TRACE] SIMAPI.Logs start")
	targetArguments := struct {
		Argid types.ID `json:"id"`
	}{
		Argid: id,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] SIMAPI.Logs end")
	}()

	result, err := t.Internal.Logs(ctx, id)
	targetResults := struct {
		Result *sacloud.SIMLogsResult
		Error  error
	}{
		Result: result,
		Error:  err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return result, err
}

// GetNetworkOperator is API call with trace log
func (t *SIMTracer) GetNetworkOperator(ctx context.Context, id types.ID) ([]*sacloud.SIMNetworkOperatorConfig, error) {
	log.Println("[TRACE] SIMAPI.GetNetworkOperator start")
	targetArguments := struct {
		Argid types.ID `json:"id"`
	}{
		Argid: id,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] SIMAPI.GetNetworkOperator end")
	}()

	resultConfigs, err := t.Internal.GetNetworkOperator(ctx, id)
	targetResults := struct {
		Configs []*sacloud.SIMNetworkOperatorConfig
		Error   error
	}{
		Configs: resultConfigs,
		Error:   err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultConfigs, err
}

// SetNetworkOperator is API call with trace log
func (t *SIMTracer) SetNetworkOperator(ctx context.Context, id types.ID, configs []*sacloud.SIMNetworkOperatorConfig) error {
	log.Println("[TRACE] SIMAPI.SetNetworkOperator start")
	targetArguments := struct {
		Argid      types.ID                            `json:"id"`
		Argconfigs []*sacloud.SIMNetworkOperatorConfig `json:"configs"`
	}{
		Argid:      id,
		Argconfigs: configs,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] SIMAPI.SetNetworkOperator end")
	}()

	err := t.Internal.SetNetworkOperator(ctx, id, configs)
	targetResults := struct {
		Error error
	}{
		Error: err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return err
}

// MonitorSIM is API call with trace log
func (t *SIMTracer) MonitorSIM(ctx context.Context, id types.ID, condition *sacloud.MonitorCondition) (*sacloud.LinkActivity, error) {
	log.Println("[TRACE] SIMAPI.MonitorSIM start")
	targetArguments := struct {
		Argid        types.ID                  `json:"id"`
		Argcondition *sacloud.MonitorCondition `json:"condition"`
	}{
		Argid:        id,
		Argcondition: condition,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] SIMAPI.MonitorSIM end")
	}()

	resultLinkActivity, err := t.Internal.MonitorSIM(ctx, id, condition)
	targetResults := struct {
		LinkActivity *sacloud.LinkActivity
		Error        error
	}{
		LinkActivity: resultLinkActivity,
		Error:        err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultLinkActivity, err
}

// Status is API call with trace log
func (t *SIMTracer) Status(ctx context.Context, id types.ID) (*sacloud.SIMInfo, error) {
	log.Println("[TRACE] SIMAPI.Status start")
	targetArguments := struct {
		Argid types.ID `json:"id"`
	}{
		Argid: id,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] SIMAPI.Status end")
	}()

	resultSIM, err := t.Internal.Status(ctx, id)
	targetResults := struct {
		SIM   *sacloud.SIMInfo
		Error error
	}{
		SIM:   resultSIM,
		Error: err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultSIM, err
}

/*************************************************
* SimpleMonitorTracer
*************************************************/

// SimpleMonitorTracer is for trace SimpleMonitorOp operations
type SimpleMonitorTracer struct {
	Internal sacloud.SimpleMonitorAPI
}

// NewSimpleMonitorTracer creates new SimpleMonitorTracer instance
func NewSimpleMonitorTracer(in sacloud.SimpleMonitorAPI) sacloud.SimpleMonitorAPI {
	return &SimpleMonitorTracer{
		Internal: in,
	}
}

// Find is API call with trace log
func (t *SimpleMonitorTracer) Find(ctx context.Context, conditions *sacloud.FindCondition) (*sacloud.SimpleMonitorFindResult, error) {
	log.Println("[TRACE] SimpleMonitorAPI.Find start")
	targetArguments := struct {
		Argconditions *sacloud.FindCondition `json:"conditions"`
	}{
		Argconditions: conditions,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] SimpleMonitorAPI.Find end")
	}()

	result, err := t.Internal.Find(ctx, conditions)
	targetResults := struct {
		Result *sacloud.SimpleMonitorFindResult
		Error  error
	}{
		Result: result,
		Error:  err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return result, err
}

// Create is API call with trace log
func (t *SimpleMonitorTracer) Create(ctx context.Context, param *sacloud.SimpleMonitorCreateRequest) (*sacloud.SimpleMonitor, error) {
	log.Println("[TRACE] SimpleMonitorAPI.Create start")
	targetArguments := struct {
		Argparam *sacloud.SimpleMonitorCreateRequest `json:"param"`
	}{
		Argparam: param,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] SimpleMonitorAPI.Create end")
	}()

	resultSimpleMonitor, err := t.Internal.Create(ctx, param)
	targetResults := struct {
		SimpleMonitor *sacloud.SimpleMonitor
		Error         error
	}{
		SimpleMonitor: resultSimpleMonitor,
		Error:         err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultSimpleMonitor, err
}

// Read is API call with trace log
func (t *SimpleMonitorTracer) Read(ctx context.Context, id types.ID) (*sacloud.SimpleMonitor, error) {
	log.Println("[TRACE] SimpleMonitorAPI.Read start")
	targetArguments := struct {
		Argid types.ID `json:"id"`
	}{
		Argid: id,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] SimpleMonitorAPI.Read end")
	}()

	resultSimpleMonitor, err := t.Internal.Read(ctx, id)
	targetResults := struct {
		SimpleMonitor *sacloud.SimpleMonitor
		Error         error
	}{
		SimpleMonitor: resultSimpleMonitor,
		Error:         err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultSimpleMonitor, err
}

// Update is API call with trace log
func (t *SimpleMonitorTracer) Update(ctx context.Context, id types.ID, param *sacloud.SimpleMonitorUpdateRequest) (*sacloud.SimpleMonitor, error) {
	log.Println("[TRACE] SimpleMonitorAPI.Update start")
	targetArguments := struct {
		Argid    types.ID                            `json:"id"`
		Argparam *sacloud.SimpleMonitorUpdateRequest `json:"param"`
	}{
		Argid:    id,
		Argparam: param,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] SimpleMonitorAPI.Update end")
	}()

	resultSimpleMonitor, err := t.Internal.Update(ctx, id, param)
	targetResults := struct {
		SimpleMonitor *sacloud.SimpleMonitor
		Error         error
	}{
		SimpleMonitor: resultSimpleMonitor,
		Error:         err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultSimpleMonitor, err
}

// UpdateSettings is API call with trace log
func (t *SimpleMonitorTracer) UpdateSettings(ctx context.Context, id types.ID, param *sacloud.SimpleMonitorUpdateSettingsRequest) (*sacloud.SimpleMonitor, error) {
	log.Println("[TRACE] SimpleMonitorAPI.UpdateSettings start")
	targetArguments := struct {
		Argid    types.ID                                    `json:"id"`
		Argparam *sacloud.SimpleMonitorUpdateSettingsRequest `json:"param"`
	}{
		Argid:    id,
		Argparam: param,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] SimpleMonitorAPI.UpdateSettings end")
	}()

	resultSimpleMonitor, err := t.Internal.UpdateSettings(ctx, id, param)
	targetResults := struct {
		SimpleMonitor *sacloud.SimpleMonitor
		Error         error
	}{
		SimpleMonitor: resultSimpleMonitor,
		Error:         err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultSimpleMonitor, err
}

// Delete is API call with trace log
func (t *SimpleMonitorTracer) Delete(ctx context.Context, id types.ID) error {
	log.Println("[TRACE] SimpleMonitorAPI.Delete start")
	targetArguments := struct {
		Argid types.ID `json:"id"`
	}{
		Argid: id,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] SimpleMonitorAPI.Delete end")
	}()

	err := t.Internal.Delete(ctx, id)
	targetResults := struct {
		Error error
	}{
		Error: err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return err
}

// MonitorResponseTime is API call with trace log
func (t *SimpleMonitorTracer) MonitorResponseTime(ctx context.Context, id types.ID, condition *sacloud.MonitorCondition) (*sacloud.ResponseTimeSecActivity, error) {
	log.Println("[TRACE] SimpleMonitorAPI.MonitorResponseTime start")
	targetArguments := struct {
		Argid        types.ID                  `json:"id"`
		Argcondition *sacloud.MonitorCondition `json:"condition"`
	}{
		Argid:        id,
		Argcondition: condition,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] SimpleMonitorAPI.MonitorResponseTime end")
	}()

	resultResponseTimeSecActivity, err := t.Internal.MonitorResponseTime(ctx, id, condition)
	targetResults := struct {
		ResponseTimeSecActivity *sacloud.ResponseTimeSecActivity
		Error                   error
	}{
		ResponseTimeSecActivity: resultResponseTimeSecActivity,
		Error:                   err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultResponseTimeSecActivity, err
}

// HealthStatus is API call with trace log
func (t *SimpleMonitorTracer) HealthStatus(ctx context.Context, id types.ID) (*sacloud.SimpleMonitorHealthStatus, error) {
	log.Println("[TRACE] SimpleMonitorAPI.HealthStatus start")
	targetArguments := struct {
		Argid types.ID `json:"id"`
	}{
		Argid: id,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] SimpleMonitorAPI.HealthStatus end")
	}()

	resultSimpleMonitorHealthStatus, err := t.Internal.HealthStatus(ctx, id)
	targetResults := struct {
		SimpleMonitorHealthStatus *sacloud.SimpleMonitorHealthStatus
		Error                     error
	}{
		SimpleMonitorHealthStatus: resultSimpleMonitorHealthStatus,
		Error:                     err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultSimpleMonitorHealthStatus, err
}

/*************************************************
* SSHKeyTracer
*************************************************/

// SSHKeyTracer is for trace SSHKeyOp operations
type SSHKeyTracer struct {
	Internal sacloud.SSHKeyAPI
}

// NewSSHKeyTracer creates new SSHKeyTracer instance
func NewSSHKeyTracer(in sacloud.SSHKeyAPI) sacloud.SSHKeyAPI {
	return &SSHKeyTracer{
		Internal: in,
	}
}

// Find is API call with trace log
func (t *SSHKeyTracer) Find(ctx context.Context, conditions *sacloud.FindCondition) (*sacloud.SSHKeyFindResult, error) {
	log.Println("[TRACE] SSHKeyAPI.Find start")
	targetArguments := struct {
		Argconditions *sacloud.FindCondition `json:"conditions"`
	}{
		Argconditions: conditions,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] SSHKeyAPI.Find end")
	}()

	result, err := t.Internal.Find(ctx, conditions)
	targetResults := struct {
		Result *sacloud.SSHKeyFindResult
		Error  error
	}{
		Result: result,
		Error:  err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return result, err
}

// Create is API call with trace log
func (t *SSHKeyTracer) Create(ctx context.Context, param *sacloud.SSHKeyCreateRequest) (*sacloud.SSHKey, error) {
	log.Println("[TRACE] SSHKeyAPI.Create start")
	targetArguments := struct {
		Argparam *sacloud.SSHKeyCreateRequest `json:"param"`
	}{
		Argparam: param,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] SSHKeyAPI.Create end")
	}()

	resultSSHKey, err := t.Internal.Create(ctx, param)
	targetResults := struct {
		SSHKey *sacloud.SSHKey
		Error  error
	}{
		SSHKey: resultSSHKey,
		Error:  err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultSSHKey, err
}

// Generate is API call with trace log
func (t *SSHKeyTracer) Generate(ctx context.Context, param *sacloud.SSHKeyGenerateRequest) (*sacloud.SSHKeyGenerated, error) {
	log.Println("[TRACE] SSHKeyAPI.Generate start")
	targetArguments := struct {
		Argparam *sacloud.SSHKeyGenerateRequest `json:"param"`
	}{
		Argparam: param,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] SSHKeyAPI.Generate end")
	}()

	resultSSHKeyGenerated, err := t.Internal.Generate(ctx, param)
	targetResults := struct {
		SSHKeyGenerated *sacloud.SSHKeyGenerated
		Error           error
	}{
		SSHKeyGenerated: resultSSHKeyGenerated,
		Error:           err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultSSHKeyGenerated, err
}

// Read is API call with trace log
func (t *SSHKeyTracer) Read(ctx context.Context, id types.ID) (*sacloud.SSHKey, error) {
	log.Println("[TRACE] SSHKeyAPI.Read start")
	targetArguments := struct {
		Argid types.ID `json:"id"`
	}{
		Argid: id,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] SSHKeyAPI.Read end")
	}()

	resultSSHKey, err := t.Internal.Read(ctx, id)
	targetResults := struct {
		SSHKey *sacloud.SSHKey
		Error  error
	}{
		SSHKey: resultSSHKey,
		Error:  err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultSSHKey, err
}

// Update is API call with trace log
func (t *SSHKeyTracer) Update(ctx context.Context, id types.ID, param *sacloud.SSHKeyUpdateRequest) (*sacloud.SSHKey, error) {
	log.Println("[TRACE] SSHKeyAPI.Update start")
	targetArguments := struct {
		Argid    types.ID                     `json:"id"`
		Argparam *sacloud.SSHKeyUpdateRequest `json:"param"`
	}{
		Argid:    id,
		Argparam: param,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] SSHKeyAPI.Update end")
	}()

	resultSSHKey, err := t.Internal.Update(ctx, id, param)
	targetResults := struct {
		SSHKey *sacloud.SSHKey
		Error  error
	}{
		SSHKey: resultSSHKey,
		Error:  err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultSSHKey, err
}

// Delete is API call with trace log
func (t *SSHKeyTracer) Delete(ctx context.Context, id types.ID) error {
	log.Println("[TRACE] SSHKeyAPI.Delete start")
	targetArguments := struct {
		Argid types.ID `json:"id"`
	}{
		Argid: id,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] SSHKeyAPI.Delete end")
	}()

	err := t.Internal.Delete(ctx, id)
	targetResults := struct {
		Error error
	}{
		Error: err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return err
}

/*************************************************
* SubnetTracer
*************************************************/

// SubnetTracer is for trace SubnetOp operations
type SubnetTracer struct {
	Internal sacloud.SubnetAPI
}

// NewSubnetTracer creates new SubnetTracer instance
func NewSubnetTracer(in sacloud.SubnetAPI) sacloud.SubnetAPI {
	return &SubnetTracer{
		Internal: in,
	}
}

// Find is API call with trace log
func (t *SubnetTracer) Find(ctx context.Context, zone string, conditions *sacloud.FindCondition) (*sacloud.SubnetFindResult, error) {
	log.Println("[TRACE] SubnetAPI.Find start")
	targetArguments := struct {
		Argzone       string
		Argconditions *sacloud.FindCondition `json:"conditions"`
	}{
		Argzone:       zone,
		Argconditions: conditions,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] SubnetAPI.Find end")
	}()

	result, err := t.Internal.Find(ctx, zone, conditions)
	targetResults := struct {
		Result *sacloud.SubnetFindResult
		Error  error
	}{
		Result: result,
		Error:  err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return result, err
}

// Read is API call with trace log
func (t *SubnetTracer) Read(ctx context.Context, zone string, id types.ID) (*sacloud.Subnet, error) {
	log.Println("[TRACE] SubnetAPI.Read start")
	targetArguments := struct {
		Argzone string
		Argid   types.ID `json:"id"`
	}{
		Argzone: zone,
		Argid:   id,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] SubnetAPI.Read end")
	}()

	resultSubnet, err := t.Internal.Read(ctx, zone, id)
	targetResults := struct {
		Subnet *sacloud.Subnet
		Error  error
	}{
		Subnet: resultSubnet,
		Error:  err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultSubnet, err
}

/*************************************************
* SwitchTracer
*************************************************/

// SwitchTracer is for trace SwitchOp operations
type SwitchTracer struct {
	Internal sacloud.SwitchAPI
}

// NewSwitchTracer creates new SwitchTracer instance
func NewSwitchTracer(in sacloud.SwitchAPI) sacloud.SwitchAPI {
	return &SwitchTracer{
		Internal: in,
	}
}

// Find is API call with trace log
func (t *SwitchTracer) Find(ctx context.Context, zone string, conditions *sacloud.FindCondition) (*sacloud.SwitchFindResult, error) {
	log.Println("[TRACE] SwitchAPI.Find start")
	targetArguments := struct {
		Argzone       string
		Argconditions *sacloud.FindCondition `json:"conditions"`
	}{
		Argzone:       zone,
		Argconditions: conditions,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] SwitchAPI.Find end")
	}()

	result, err := t.Internal.Find(ctx, zone, conditions)
	targetResults := struct {
		Result *sacloud.SwitchFindResult
		Error  error
	}{
		Result: result,
		Error:  err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return result, err
}

// Create is API call with trace log
func (t *SwitchTracer) Create(ctx context.Context, zone string, param *sacloud.SwitchCreateRequest) (*sacloud.Switch, error) {
	log.Println("[TRACE] SwitchAPI.Create start")
	targetArguments := struct {
		Argzone  string
		Argparam *sacloud.SwitchCreateRequest `json:"param"`
	}{
		Argzone:  zone,
		Argparam: param,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] SwitchAPI.Create end")
	}()

	resultSwitch, err := t.Internal.Create(ctx, zone, param)
	targetResults := struct {
		Switch *sacloud.Switch
		Error  error
	}{
		Switch: resultSwitch,
		Error:  err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultSwitch, err
}

// Read is API call with trace log
func (t *SwitchTracer) Read(ctx context.Context, zone string, id types.ID) (*sacloud.Switch, error) {
	log.Println("[TRACE] SwitchAPI.Read start")
	targetArguments := struct {
		Argzone string
		Argid   types.ID `json:"id"`
	}{
		Argzone: zone,
		Argid:   id,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] SwitchAPI.Read end")
	}()

	resultSwitch, err := t.Internal.Read(ctx, zone, id)
	targetResults := struct {
		Switch *sacloud.Switch
		Error  error
	}{
		Switch: resultSwitch,
		Error:  err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultSwitch, err
}

// Update is API call with trace log
func (t *SwitchTracer) Update(ctx context.Context, zone string, id types.ID, param *sacloud.SwitchUpdateRequest) (*sacloud.Switch, error) {
	log.Println("[TRACE] SwitchAPI.Update start")
	targetArguments := struct {
		Argzone  string
		Argid    types.ID                     `json:"id"`
		Argparam *sacloud.SwitchUpdateRequest `json:"param"`
	}{
		Argzone:  zone,
		Argid:    id,
		Argparam: param,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] SwitchAPI.Update end")
	}()

	resultSwitch, err := t.Internal.Update(ctx, zone, id, param)
	targetResults := struct {
		Switch *sacloud.Switch
		Error  error
	}{
		Switch: resultSwitch,
		Error:  err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultSwitch, err
}

// Delete is API call with trace log
func (t *SwitchTracer) Delete(ctx context.Context, zone string, id types.ID) error {
	log.Println("[TRACE] SwitchAPI.Delete start")
	targetArguments := struct {
		Argzone string
		Argid   types.ID `json:"id"`
	}{
		Argzone: zone,
		Argid:   id,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] SwitchAPI.Delete end")
	}()

	err := t.Internal.Delete(ctx, zone, id)
	targetResults := struct {
		Error error
	}{
		Error: err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return err
}

// ConnectToBridge is API call with trace log
func (t *SwitchTracer) ConnectToBridge(ctx context.Context, zone string, id types.ID, bridgeID types.ID) error {
	log.Println("[TRACE] SwitchAPI.ConnectToBridge start")
	targetArguments := struct {
		Argzone     string
		Argid       types.ID `json:"id"`
		ArgbridgeID types.ID `json:"bridgeID"`
	}{
		Argzone:     zone,
		Argid:       id,
		ArgbridgeID: bridgeID,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] SwitchAPI.ConnectToBridge end")
	}()

	err := t.Internal.ConnectToBridge(ctx, zone, id, bridgeID)
	targetResults := struct {
		Error error
	}{
		Error: err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return err
}

// DisconnectFromBridge is API call with trace log
func (t *SwitchTracer) DisconnectFromBridge(ctx context.Context, zone string, id types.ID) error {
	log.Println("[TRACE] SwitchAPI.DisconnectFromBridge start")
	targetArguments := struct {
		Argzone string
		Argid   types.ID `json:"id"`
	}{
		Argzone: zone,
		Argid:   id,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] SwitchAPI.DisconnectFromBridge end")
	}()

	err := t.Internal.DisconnectFromBridge(ctx, zone, id)
	targetResults := struct {
		Error error
	}{
		Error: err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return err
}

// GetServers is API call with trace log
func (t *SwitchTracer) GetServers(ctx context.Context, zone string, id types.ID) (*sacloud.SwitchGetServersResult, error) {
	log.Println("[TRACE] SwitchAPI.GetServers start")
	targetArguments := struct {
		Argzone string
		Argid   types.ID `json:"id"`
	}{
		Argzone: zone,
		Argid:   id,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] SwitchAPI.GetServers end")
	}()

	result, err := t.Internal.GetServers(ctx, zone, id)
	targetResults := struct {
		Result *sacloud.SwitchGetServersResult
		Error  error
	}{
		Result: result,
		Error:  err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return result, err
}

/*************************************************
* VPCRouterTracer
*************************************************/

// VPCRouterTracer is for trace VPCRouterOp operations
type VPCRouterTracer struct {
	Internal sacloud.VPCRouterAPI
}

// NewVPCRouterTracer creates new VPCRouterTracer instance
func NewVPCRouterTracer(in sacloud.VPCRouterAPI) sacloud.VPCRouterAPI {
	return &VPCRouterTracer{
		Internal: in,
	}
}

// Find is API call with trace log
func (t *VPCRouterTracer) Find(ctx context.Context, zone string, conditions *sacloud.FindCondition) (*sacloud.VPCRouterFindResult, error) {
	log.Println("[TRACE] VPCRouterAPI.Find start")
	targetArguments := struct {
		Argzone       string
		Argconditions *sacloud.FindCondition `json:"conditions"`
	}{
		Argzone:       zone,
		Argconditions: conditions,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] VPCRouterAPI.Find end")
	}()

	result, err := t.Internal.Find(ctx, zone, conditions)
	targetResults := struct {
		Result *sacloud.VPCRouterFindResult
		Error  error
	}{
		Result: result,
		Error:  err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return result, err
}

// Create is API call with trace log
func (t *VPCRouterTracer) Create(ctx context.Context, zone string, param *sacloud.VPCRouterCreateRequest) (*sacloud.VPCRouter, error) {
	log.Println("[TRACE] VPCRouterAPI.Create start")
	targetArguments := struct {
		Argzone  string
		Argparam *sacloud.VPCRouterCreateRequest `json:"param"`
	}{
		Argzone:  zone,
		Argparam: param,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] VPCRouterAPI.Create end")
	}()

	resultVPCRouter, err := t.Internal.Create(ctx, zone, param)
	targetResults := struct {
		VPCRouter *sacloud.VPCRouter
		Error     error
	}{
		VPCRouter: resultVPCRouter,
		Error:     err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultVPCRouter, err
}

// Read is API call with trace log
func (t *VPCRouterTracer) Read(ctx context.Context, zone string, id types.ID) (*sacloud.VPCRouter, error) {
	log.Println("[TRACE] VPCRouterAPI.Read start")
	targetArguments := struct {
		Argzone string
		Argid   types.ID `json:"id"`
	}{
		Argzone: zone,
		Argid:   id,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] VPCRouterAPI.Read end")
	}()

	resultVPCRouter, err := t.Internal.Read(ctx, zone, id)
	targetResults := struct {
		VPCRouter *sacloud.VPCRouter
		Error     error
	}{
		VPCRouter: resultVPCRouter,
		Error:     err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultVPCRouter, err
}

// Update is API call with trace log
func (t *VPCRouterTracer) Update(ctx context.Context, zone string, id types.ID, param *sacloud.VPCRouterUpdateRequest) (*sacloud.VPCRouter, error) {
	log.Println("[TRACE] VPCRouterAPI.Update start")
	targetArguments := struct {
		Argzone  string
		Argid    types.ID                        `json:"id"`
		Argparam *sacloud.VPCRouterUpdateRequest `json:"param"`
	}{
		Argzone:  zone,
		Argid:    id,
		Argparam: param,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] VPCRouterAPI.Update end")
	}()

	resultVPCRouter, err := t.Internal.Update(ctx, zone, id, param)
	targetResults := struct {
		VPCRouter *sacloud.VPCRouter
		Error     error
	}{
		VPCRouter: resultVPCRouter,
		Error:     err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultVPCRouter, err
}

// UpdateSettings is API call with trace log
func (t *VPCRouterTracer) UpdateSettings(ctx context.Context, zone string, id types.ID, param *sacloud.VPCRouterUpdateSettingsRequest) (*sacloud.VPCRouter, error) {
	log.Println("[TRACE] VPCRouterAPI.UpdateSettings start")
	targetArguments := struct {
		Argzone  string
		Argid    types.ID                                `json:"id"`
		Argparam *sacloud.VPCRouterUpdateSettingsRequest `json:"param"`
	}{
		Argzone:  zone,
		Argid:    id,
		Argparam: param,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] VPCRouterAPI.UpdateSettings end")
	}()

	resultVPCRouter, err := t.Internal.UpdateSettings(ctx, zone, id, param)
	targetResults := struct {
		VPCRouter *sacloud.VPCRouter
		Error     error
	}{
		VPCRouter: resultVPCRouter,
		Error:     err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultVPCRouter, err
}

// Delete is API call with trace log
func (t *VPCRouterTracer) Delete(ctx context.Context, zone string, id types.ID) error {
	log.Println("[TRACE] VPCRouterAPI.Delete start")
	targetArguments := struct {
		Argzone string
		Argid   types.ID `json:"id"`
	}{
		Argzone: zone,
		Argid:   id,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] VPCRouterAPI.Delete end")
	}()

	err := t.Internal.Delete(ctx, zone, id)
	targetResults := struct {
		Error error
	}{
		Error: err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return err
}

// Config is API call with trace log
func (t *VPCRouterTracer) Config(ctx context.Context, zone string, id types.ID) error {
	log.Println("[TRACE] VPCRouterAPI.Config start")
	targetArguments := struct {
		Argzone string
		Argid   types.ID `json:"id"`
	}{
		Argzone: zone,
		Argid:   id,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] VPCRouterAPI.Config end")
	}()

	err := t.Internal.Config(ctx, zone, id)
	targetResults := struct {
		Error error
	}{
		Error: err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return err
}

// Boot is API call with trace log
func (t *VPCRouterTracer) Boot(ctx context.Context, zone string, id types.ID) error {
	log.Println("[TRACE] VPCRouterAPI.Boot start")
	targetArguments := struct {
		Argzone string
		Argid   types.ID `json:"id"`
	}{
		Argzone: zone,
		Argid:   id,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] VPCRouterAPI.Boot end")
	}()

	err := t.Internal.Boot(ctx, zone, id)
	targetResults := struct {
		Error error
	}{
		Error: err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return err
}

// Shutdown is API call with trace log
func (t *VPCRouterTracer) Shutdown(ctx context.Context, zone string, id types.ID, shutdownOption *sacloud.ShutdownOption) error {
	log.Println("[TRACE] VPCRouterAPI.Shutdown start")
	targetArguments := struct {
		Argzone           string
		Argid             types.ID                `json:"id"`
		ArgshutdownOption *sacloud.ShutdownOption `json:"shutdownOption"`
	}{
		Argzone:           zone,
		Argid:             id,
		ArgshutdownOption: shutdownOption,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] VPCRouterAPI.Shutdown end")
	}()

	err := t.Internal.Shutdown(ctx, zone, id, shutdownOption)
	targetResults := struct {
		Error error
	}{
		Error: err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return err
}

// Reset is API call with trace log
func (t *VPCRouterTracer) Reset(ctx context.Context, zone string, id types.ID) error {
	log.Println("[TRACE] VPCRouterAPI.Reset start")
	targetArguments := struct {
		Argzone string
		Argid   types.ID `json:"id"`
	}{
		Argzone: zone,
		Argid:   id,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] VPCRouterAPI.Reset end")
	}()

	err := t.Internal.Reset(ctx, zone, id)
	targetResults := struct {
		Error error
	}{
		Error: err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return err
}

// ConnectToSwitch is API call with trace log
func (t *VPCRouterTracer) ConnectToSwitch(ctx context.Context, zone string, id types.ID, nicIndex int, switchID types.ID) error {
	log.Println("[TRACE] VPCRouterAPI.ConnectToSwitch start")
	targetArguments := struct {
		Argzone     string
		Argid       types.ID `json:"id"`
		ArgnicIndex int      `json:"nicIndex"`
		ArgswitchID types.ID `json:"switchID"`
	}{
		Argzone:     zone,
		Argid:       id,
		ArgnicIndex: nicIndex,
		ArgswitchID: switchID,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] VPCRouterAPI.ConnectToSwitch end")
	}()

	err := t.Internal.ConnectToSwitch(ctx, zone, id, nicIndex, switchID)
	targetResults := struct {
		Error error
	}{
		Error: err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return err
}

// DisconnectFromSwitch is API call with trace log
func (t *VPCRouterTracer) DisconnectFromSwitch(ctx context.Context, zone string, id types.ID, nicIndex int) error {
	log.Println("[TRACE] VPCRouterAPI.DisconnectFromSwitch start")
	targetArguments := struct {
		Argzone     string
		Argid       types.ID `json:"id"`
		ArgnicIndex int      `json:"nicIndex"`
	}{
		Argzone:     zone,
		Argid:       id,
		ArgnicIndex: nicIndex,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] VPCRouterAPI.DisconnectFromSwitch end")
	}()

	err := t.Internal.DisconnectFromSwitch(ctx, zone, id, nicIndex)
	targetResults := struct {
		Error error
	}{
		Error: err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return err
}

// MonitorCPU is API call with trace log
func (t *VPCRouterTracer) MonitorCPU(ctx context.Context, zone string, id types.ID, condition *sacloud.MonitorCondition) (*sacloud.CPUTimeActivity, error) {
	log.Println("[TRACE] VPCRouterAPI.MonitorCPU start")
	targetArguments := struct {
		Argzone      string
		Argid        types.ID                  `json:"id"`
		Argcondition *sacloud.MonitorCondition `json:"condition"`
	}{
		Argzone:      zone,
		Argid:        id,
		Argcondition: condition,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] VPCRouterAPI.MonitorCPU end")
	}()

	resultCPUTimeActivity, err := t.Internal.MonitorCPU(ctx, zone, id, condition)
	targetResults := struct {
		CPUTimeActivity *sacloud.CPUTimeActivity
		Error           error
	}{
		CPUTimeActivity: resultCPUTimeActivity,
		Error:           err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultCPUTimeActivity, err
}

// MonitorInterface is API call with trace log
func (t *VPCRouterTracer) MonitorInterface(ctx context.Context, zone string, id types.ID, index int, condition *sacloud.MonitorCondition) (*sacloud.InterfaceActivity, error) {
	log.Println("[TRACE] VPCRouterAPI.MonitorInterface start")
	targetArguments := struct {
		Argzone      string
		Argid        types.ID                  `json:"id"`
		Argindex     int                       `json:"index"`
		Argcondition *sacloud.MonitorCondition `json:"condition"`
	}{
		Argzone:      zone,
		Argid:        id,
		Argindex:     index,
		Argcondition: condition,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] VPCRouterAPI.MonitorInterface end")
	}()

	resultInterfaceActivity, err := t.Internal.MonitorInterface(ctx, zone, id, index, condition)
	targetResults := struct {
		InterfaceActivity *sacloud.InterfaceActivity
		Error             error
	}{
		InterfaceActivity: resultInterfaceActivity,
		Error:             err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultInterfaceActivity, err
}

// Status is API call with trace log
func (t *VPCRouterTracer) Status(ctx context.Context, zone string, id types.ID) (*sacloud.VPCRouterStatus, error) {
	log.Println("[TRACE] VPCRouterAPI.Status start")
	targetArguments := struct {
		Argzone string
		Argid   types.ID `json:"id"`
	}{
		Argzone: zone,
		Argid:   id,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] VPCRouterAPI.Status end")
	}()

	resultVPCRouterStatus, err := t.Internal.Status(ctx, zone, id)
	targetResults := struct {
		VPCRouterStatus *sacloud.VPCRouterStatus
		Error           error
	}{
		VPCRouterStatus: resultVPCRouterStatus,
		Error:           err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultVPCRouterStatus, err
}

/*************************************************
* WebAccelTracer
*************************************************/

// WebAccelTracer is for trace WebAccelOp operations
type WebAccelTracer struct {
	Internal sacloud.WebAccelAPI
}

// NewWebAccelTracer creates new WebAccelTracer instance
func NewWebAccelTracer(in sacloud.WebAccelAPI) sacloud.WebAccelAPI {
	return &WebAccelTracer{
		Internal: in,
	}
}

// List is API call with trace log
func (t *WebAccelTracer) List(ctx context.Context) (*sacloud.WebAccelListResult, error) {
	log.Println("[TRACE] WebAccelAPI.List start")
	targetArguments := struct {
	}{}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] WebAccelAPI.List end")
	}()

	result, err := t.Internal.List(ctx)
	targetResults := struct {
		Result *sacloud.WebAccelListResult
		Error  error
	}{
		Result: result,
		Error:  err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return result, err
}

// Read is API call with trace log
func (t *WebAccelTracer) Read(ctx context.Context, id types.ID) (*sacloud.WebAccel, error) {
	log.Println("[TRACE] WebAccelAPI.Read start")
	targetArguments := struct {
		Argid types.ID `json:"id"`
	}{
		Argid: id,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] WebAccelAPI.Read end")
	}()

	resultWebAccel, err := t.Internal.Read(ctx, id)
	targetResults := struct {
		WebAccel *sacloud.WebAccel
		Error    error
	}{
		WebAccel: resultWebAccel,
		Error:    err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultWebAccel, err
}

// ReadCertificate is API call with trace log
func (t *WebAccelTracer) ReadCertificate(ctx context.Context, id types.ID) (*sacloud.WebAccelCerts, error) {
	log.Println("[TRACE] WebAccelAPI.ReadCertificate start")
	targetArguments := struct {
		Argid types.ID `json:"id"`
	}{
		Argid: id,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] WebAccelAPI.ReadCertificate end")
	}()

	resultCertificate, err := t.Internal.ReadCertificate(ctx, id)
	targetResults := struct {
		Certificate *sacloud.WebAccelCerts
		Error       error
	}{
		Certificate: resultCertificate,
		Error:       err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultCertificate, err
}

// CreateCertificate is API call with trace log
func (t *WebAccelTracer) CreateCertificate(ctx context.Context, id types.ID, param *sacloud.WebAccelCertRequest) (*sacloud.WebAccelCerts, error) {
	log.Println("[TRACE] WebAccelAPI.CreateCertificate start")
	targetArguments := struct {
		Argid    types.ID                     `json:"id"`
		Argparam *sacloud.WebAccelCertRequest `json:"param"`
	}{
		Argid:    id,
		Argparam: param,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] WebAccelAPI.CreateCertificate end")
	}()

	resultCertificate, err := t.Internal.CreateCertificate(ctx, id, param)
	targetResults := struct {
		Certificate *sacloud.WebAccelCerts
		Error       error
	}{
		Certificate: resultCertificate,
		Error:       err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultCertificate, err
}

// UpdateCertificate is API call with trace log
func (t *WebAccelTracer) UpdateCertificate(ctx context.Context, id types.ID, param *sacloud.WebAccelCertRequest) (*sacloud.WebAccelCerts, error) {
	log.Println("[TRACE] WebAccelAPI.UpdateCertificate start")
	targetArguments := struct {
		Argid    types.ID                     `json:"id"`
		Argparam *sacloud.WebAccelCertRequest `json:"param"`
	}{
		Argid:    id,
		Argparam: param,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] WebAccelAPI.UpdateCertificate end")
	}()

	resultCertificate, err := t.Internal.UpdateCertificate(ctx, id, param)
	targetResults := struct {
		Certificate *sacloud.WebAccelCerts
		Error       error
	}{
		Certificate: resultCertificate,
		Error:       err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultCertificate, err
}

// DeleteCertificate is API call with trace log
func (t *WebAccelTracer) DeleteCertificate(ctx context.Context, id types.ID) error {
	log.Println("[TRACE] WebAccelAPI.DeleteCertificate start")
	targetArguments := struct {
		Argid types.ID `json:"id"`
	}{
		Argid: id,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] WebAccelAPI.DeleteCertificate end")
	}()

	err := t.Internal.DeleteCertificate(ctx, id)
	targetResults := struct {
		Error error
	}{
		Error: err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return err
}

// DeleteAllCache is API call with trace log
func (t *WebAccelTracer) DeleteAllCache(ctx context.Context, param *sacloud.WebAccelDeleteAllCacheRequest) error {
	log.Println("[TRACE] WebAccelAPI.DeleteAllCache start")
	targetArguments := struct {
		Argparam *sacloud.WebAccelDeleteAllCacheRequest `json:"param"`
	}{
		Argparam: param,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] WebAccelAPI.DeleteAllCache end")
	}()

	err := t.Internal.DeleteAllCache(ctx, param)
	targetResults := struct {
		Error error
	}{
		Error: err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return err
}

// DeleteCache is API call with trace log
func (t *WebAccelTracer) DeleteCache(ctx context.Context, param *sacloud.WebAccelDeleteCacheRequest) ([]*sacloud.WebAccelDeleteCacheResult, error) {
	log.Println("[TRACE] WebAccelAPI.DeleteCache start")
	targetArguments := struct {
		Argparam *sacloud.WebAccelDeleteCacheRequest `json:"param"`
	}{
		Argparam: param,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] WebAccelAPI.DeleteCache end")
	}()

	resultResults, err := t.Internal.DeleteCache(ctx, param)
	targetResults := struct {
		Results []*sacloud.WebAccelDeleteCacheResult
		Error   error
	}{
		Results: resultResults,
		Error:   err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultResults, err
}

/*************************************************
* ZoneTracer
*************************************************/

// ZoneTracer is for trace ZoneOp operations
type ZoneTracer struct {
	Internal sacloud.ZoneAPI
}

// NewZoneTracer creates new ZoneTracer instance
func NewZoneTracer(in sacloud.ZoneAPI) sacloud.ZoneAPI {
	return &ZoneTracer{
		Internal: in,
	}
}

// Find is API call with trace log
func (t *ZoneTracer) Find(ctx context.Context, conditions *sacloud.FindCondition) (*sacloud.ZoneFindResult, error) {
	log.Println("[TRACE] ZoneAPI.Find start")
	targetArguments := struct {
		Argconditions *sacloud.FindCondition `json:"conditions"`
	}{
		Argconditions: conditions,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] ZoneAPI.Find end")
	}()

	result, err := t.Internal.Find(ctx, conditions)
	targetResults := struct {
		Result *sacloud.ZoneFindResult
		Error  error
	}{
		Result: result,
		Error:  err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return result, err
}

// Read is API call with trace log
func (t *ZoneTracer) Read(ctx context.Context, id types.ID) (*sacloud.Zone, error) {
	log.Println("[TRACE] ZoneAPI.Read start")
	targetArguments := struct {
		Argid types.ID `json:"id"`
	}{
		Argid: id,
	}
	if d, err := json.Marshal(targetArguments); err == nil {
		log.Printf("[TRACE] \targs: %s\n", string(d))
	}

	defer func() {
		log.Println("[TRACE] ZoneAPI.Read end")
	}()

	resultZone, err := t.Internal.Read(ctx, id)
	targetResults := struct {
		Zone  *sacloud.Zone
		Error error
	}{
		Zone:  resultZone,
		Error: err,
	}
	if d, err := json.Marshal(targetResults); err == nil {
		log.Printf("[TRACE] \tresults: %s\n", string(d))
	}

	return resultZone, err
}
